come trovo tutti i file contenenti testo specifico su Linux?

sto cercando di trovare un modo per eseguire la scansione del mio intero sistema Linux per tutti i file contenenti una specifica stringa di testo. solo per chiarire, sto cercando il testo all'interno del file, non nel nome del file.

quando stavo cercando su come fare questo, mi sono imbattuto in questa soluzione due volte:

find/-type f -exec grep -H 'text-to-find-here' {} \;

tuttavia, non funziona. sembra visualizzare ogni singolo file nel sistema.

è questo vicino al modo corretto per farlo? se no, come dovrei? questa capacità di trovare stringhe di testo nei file sarebbe straordinariamente utile per alcuni progetti di programmazione che sto facendo.


En title : How do I find all files containing specific text on Linux?

175 Comments:

  1. è possibile utilizzare grep -ilR:

    grep -Ril "text-to-find-here" /
    
    • i sta per ignore case (opzionale nel tuo caso).
    • R significa ricorsivo.
    • l sta per "mostrare il nome del file, non il risultato stesso".
    • / sta per partire alla radice della vostra macchina.
    1. quanto tempo in media (ovviamente dipende molto dal sistema) pensi che questo sarebbe necessario per la scansione del sistema completo?

      pensi che usare un'espressione regolare con grep renderebbe più veloce?

    1. sulla base della mia esperienza, il -i rende rallentare un sacco, quindi non usarlo se non necessario. testarlo in una certa dir e poi generalizzare. dovrebbe essere completato in pochi minuti. penso che un'espressione regolare renderebbe più lento. ma i miei commenti si basano su supposizioni, vi suggerisco di provarlo con time di fronte alla linea.
    1. sì, /* sta per questo. comunque ho appena provato e notato che solo / funziona.
    1. OK, grazie.

      sembra che questo sia catturare un sacco di file che non posso nemmeno aprire in un editor di testo. è forse interpretare tutti i formati a testo, e così casualmente trovare risultati in binario "rumore" in un file eseguibile, per esempio?

    1. @wired00 Di sicuro, con -i è sicuramente più lento, ma è complicato sapere quanto: se si esegue il test con e senza, probabilmente i risultati del primo sono memorizzati nella cache e utilizzati durante l'esecuzione del secondo. inoltre, è più "costoso" controllare una parola lunga (aBcDEFghIj) che una parola corta (aBc), perché ci sono molte più combinazioni possibili di maiuscole / minuscole.
    1. @fedorqui Ahh yep capito, actaully quello che ho usato se ora è il comando ack 'search text', funziona davvero bene per quello che avevo bisogno per ed è molto veloce. il suo bello a causa della bella evidenziazione che utilizza.
    1. è possibile sostituire / con il percorso della directory grep -Ril "text-to-find-here" ~/sites/ o usare. per la directory corrente grep -Ril "text-to-find-here" .
    1. @Nathan dopo tutto questo tempo (e più di un milione di visualizzazioni!) ho notato che è possibile aggiungere il parametro -I (capitale i) per escludere i file binari. penso che questo sia stato il punto chiave qui, invece di exclude o include. meglio tardi che mai: d
    1. @fedorqui Grazie! e so, 1,5 milioni di visualizzazioni.. abbastanza pazzo, giusto? apprezzo la risposta che hai dato 2 anni fa:)
    1. @Nathan molto pazzo!! la cosa divertente è che questo è diventato un Q & amp canonico; A sulla ricerca di una stringa, anche se il vero problema era di escludere i file binari:)
    1. grep -rl 'pattern' . opere ricorsive anche con minuscolo -r. ricerca Scope dot . per la directory corrente è più intuitivo AFAIK rathan di /
    1. @nitinr708i -R e -r sono diversi. da man grep: leggere tutti i file in ogni directory, ricorsivamente. segui tutti i link, a differenza di -r.
    1. e 'possibile visualizzare anche il numero di linea nel file in cui appare la stringa?
    1. -i molto utile soprattutto quando si naviga attraverso il codice qualcun altro fatto. alcune lingue come Fortran sono insensibili alle maiuscole quando dichiara funzioni: funzione / funzione manichino (x)..
    1. @fedorqui: Sono sorpreso di sentire che grep rallenta su -i e parole lunghe, come avrei dovuto pensare che l'algoritmo di ricerca stringa "generated-skip-length-table-driven" di Boyer-Moore sarebbe altrettanto veloce su -i e più veloce su parole più lunghe - presumibilmente Linux grep sta usando qualcosa di più semplice! ma https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore ricerca stringa _ algoritmo # Implementazioni dice che viene utilizzato!
    1. @PJTraill Non conosco le specifiche. il buon senso direbbe che cercare "abc" è più facile di "Abc", "ABC", "ABC" e così via, e gli esempi di timing mi hanno mostrato una grande differenza. ma sono sicuro che ne sai di più di me! forse vale una domanda?
    1. @fedorqui Possiamo ottenere un esempio di come applicare questo solo a file specifici? per esempio, trova tutte le istanze di filename.txt che contengono testo 'x' (ricorsivo)? grazie "
  2. effettuare le seguenti operazioni:

    grep -rnw '/path/to/somewhere/' -e 'pattern'
    
    • -r o -R è ricorsivo,
    • -n è il numero di linea, e
    • -w significa che corrisponde all'intera parola.
    • -l (minuscola L) può essere aggiunto solo per dare il nome del file di file corrispondenti.

    insieme a questi, --exclude, --include, --exclude-dir bandiere potrebbero essere utilizzati per una ricerca efficiente:

    • questo ricerca solo attraverso quei file che hanno estensioni .c o .h:

      grep --include=\*.{c,h} -rnw '/path/to/somewhere/' -e "pattern"
      
    • questo escluderà la ricerca di tutti i file che terminano con estensione .o:

      grep --exclude=*.o -rnw '/path/to/somewhere/' -e "pattern"
      
    • per le directory è possibile escludere una directory particolare (ies) attraverso il parametro --exclude-dir. per esempio, questo escluderà i dirs dir1 /, dir2 / e tutti corrispondenti * .dst /:

      grep --exclude-dir={dir1,dir2,*.dst} -rnw '/path/to/somewhere/' -e "pattern"
      

    questo funziona molto bene per me, per raggiungere quasi lo stesso scopo come il vostro.

    per ulteriori opzioni controllare man grep.

    1. trovo grep --include parametro molto utile. per esempio:

      grep -rnw --include = * .java. -e "quello che sto cercando"

    1. questo potrebbe anche aiutare: http://jason4zhu.blogspot.jp/2014/10/test-post.html
    1. se non funziona deselezionare la directory. inoltre, se si tratta di una grande directory può semplicemente appendere per un secondo. non è istantanea.
    1. non funziona quando si cerca di trovare qualcosa come "foo @ email.com" tornerà per "email.com" ma non appena si lancia il (At) [@] simbolo nella stringa, grep soffoca e restituisce zip.
    1. funziona bene, ma se aggiungo "-i" per ignorare caso, restituisce qualche risultato falso. qualcuno ha incontrato lo stesso problema?
    1. vale la pena notare: sembra che l'opzione r sia lazy (attraversa la depth-first, poi si ferma dopo la prima directory), mentre R è greedy (attraverserà correttamente l'intero albero).
    1. Ciao, una domanda ingenua: perché si utilizza & # 42;. {..} dopo -incluso, ma *. {...} dopo -escluso?
    1. @zell per indicare il tipo di file che vogliamo cercare. dall'alto ex, abbiamo solo voluto cercare i file finiscono con estensione .c e .h.
    1. non dimenticate di dire a Linux di non mostrarvi le cose di cui non avete bisogno aggiungendo "2 > / dev / null" alla fine del comando. questo è l'unico a non ottenere un sacco di avvertimenti Permission Denied che solo fangoso i risultati che stai cercando.
    1. nota (specialmente per i neofiti): le virgolette nel comando precedente sono importanti.
    1. è possibile aggiungere --color / --color per evidenziare anche il termine di ricerca. ad esempio grep -rnw --colour . -e "terminal"
    1. @sbhatla se il nome del file o il percorso del file contiene spazi bianchi, le virgolette assicurano che il nome del file venga letto includendo / along-con spazi bianchi.
    1. @Eliran Malka R en r percorre correttamente le directory, ma R segue collegamenti simbolici.
    1. preferisco ottenere solo i nomi dei file senza il risultato, quindi uso grep -rnwl
    1. cerca in file / directory nascosti all'interno della directory?
    1. la tua risposta non funziona per un gran numero di file, testati in AIX per più di 15k file non ha funzionato. errore - errore -

      "/ usr / bin / grep: 0403-027 L'elenco dei parametri è troppo lungo."

    1. su Ubuntu 14.04.3 questo non ha funzionato. ho montato la directory in Samba e ha trovato il testo.
    1. qualcuno può spiegare perché c'è un argomento include\ in --include = & # 92; *? grazie grazie grazie grazie grazie
    1. trovo l'opzione -i molto utile anche per "ignorare caso". forse gettare questo nella tua lista di opzioni.
    1. questa è una risposta solida, ma il problema è che combatterà solo parole intere a causa del parametro -w. ho trovato che non corrisponde a testo arbitrario.
    1. la cosa che vorrei aggiungere a questa risposta è che '/ path / to / where /' non può essere un percorso relativo. dovrebbe essere un percorso assoluto dalla directory /.
    1. ho usato il vostro comando in funzione con .bashrc

      findin () {

      grep -rnw "$2" -e "$1"

      }}}}}}

    1. --include-dir flag genera un errore e non è menzionato nella pagina man di grep (almeno non nelle mie macchine centos e debian).
    1. @sf_admin Hai ragione, in realtà non c'è opzione --include-dir. mi chiedevo quando questo è stato incluso, sulla mia prima versione? non ricordo. sarebbe bello se fosse possibile vedere la risposta cambiare log come git.
    1. o più minimalista, grep -r 'rrr' ./. (o come detto -R invece di -r, in modo da includere collegamenti simbolici)
    1. una delle stringhe che cercavo conteneva personaggi speciali. si desidera aggiungere un -F in modo che conti alfabetizzati di stringa.
  3. puoi usare ack. è come grep per il codice sorgente. è possibile eseguire la scansione dell'intero file system con esso.

    basta fare:

    ack 'text-to-find-here'
    

    nella tua directory root.

    è inoltre possibile utilizzare espressioni regolari, specificare il tipo di file, ecc.


    aggiornamento aggiornamento aggiornamento aggiornamento

    ho appena scoperto The Silver Searcher, che è come un errore ma 3-5x più veloce di esso e anche ignora i modelli da un .gitignore file.

    1. molto utile, semplice e veloce. attenzione: "sulle distribuzioni derivate da Debian, ack è impacchettato come" ack-grep "perché" ack "esisteva già" (da http://beyondgrep.com/install/). si può finire per eseguire un convertitore di codice Kanji su quei Linuxes...
    1. ACK o ack-grep ha dei bei highlights, ma trova + grep quando usato correttamente è molto meglio nelle prestazioni
    1. più facile, prolisso, ricorsivo e case insensibili. pollici in alto.
  4. ricorda che grep interpreterà qualsiasi . come un carattere singolo, tra gli altri. il mio consiglio è quello di usare alway o fgrep o egrep.
  5. comunque, eri quasi lì! basta sostituire -H con -l (e forse grep con fgrep). per escludere i file con determinati modelli di nomi si utilizza find in modo più avanzato. è opportuno imparare ad usare find, però. solo man find.
  6. elenco dei nomi dei file contenenti un dato testo

    prima di tutto, credo che tu abbia usato -H invece di -l. inoltre puoi provare ad aggiungere il testo tra virgolette seguito da {} \.

    find / -type f -exec grep -l "text-to-find-here" {} \; 
    

    esempio di esempio

    diciamo che stai cercando dei file contenenti un testo specifico "Apache License" nella tua directory. mostrerà i risultati in qualche modo simili a sotto (l'uscita sarà differente basato sul vostro soddisfare di indice).

    bash-4.1$ find . -type f -exec grep -l "Apache License" {} \; 
    ./net/java/jvnet-parent/5/jvnet-parent-5.pom
    ./commons-cli/commons-cli/1.3.1/commons-cli-1.3.1.pom
    ./io/swagger/swagger-project/1.5.10/swagger-project-1.5.10.pom
    ./io/netty/netty-transport/4.1.7.Final/netty-transport-4.1.7.Final.pom
    ./commons-codec/commons-codec/1.9/commons-codec-1.9.pom
    ./commons-io/commons-io/2.4/commons-io-2.4.pom
    bash-4.1$ 
    

    rimuovere sensibilità caso

    anche se non si utilizza il caso come "text" vs "TEXT", è possibile utilizzare l'opzione -i per ignorare il caso. potete leggere ulteriori dettagli qui.

    spero che questo ti aiuti.

    1. che cosa fa questo comando: find passerà tutti i percorsi che trova al comando grep -l "text-to-find-here" <file found>". è possibile aggiungere restrizioni al nome del file, ad esempio find / -iname "*.txt" per cercare solo nei file che il nome finisce in .txt
    1. @Auxiliary - incluso un output di esempio per evitare confusione per i lettori.
    1. @Mene E 'uno stato veramente triste che il commento di Ausiliare ha più voti del tuo... anche se il loro commento è da 2014 e il tuo è 2017 che il loro commento ha 6 quando dovrebbe avere esattamente 0 e il tuo aveva solo uno (ora due) non è qualcosa che mi piacerebbe credere.
    1. @Mene Che detto -iname è case-insensibili il che significa che sarebbe anche trovare i file .TXT, per esempio, così come TXT e TXT e così via.
  7. ho scritto uno script Python che fa qualcosa di simile. questo è come si dovrebbe usare questo script.

    ./sniff.py path pattern_to_search [file_pattern]
    

    il primo argomento, path, è la directory in cui cercheremo ricorsivamente. il secondo argomento, pattern_to_search, è un'espressione regolare che vogliamo cercare in un file. usiamo il formato di espressione regolare definito nella libreria Python re. in questo script, il . corrisponde anche a newline.

    il terzo argomento, file_pattern, è opzionale. questa è un'altra espressione regolare che funziona su un nome di file. verranno considerati solo i file che corrispondono a questa espressione regolare.

    per esempio, se voglio cercare i file Python con l'estensione py contenente Pool( seguita dalla parola Adaptor, faccio quanto segue,

    ./sniff.py . "Pool(.*?Adaptor"  .*py
    ./Demos/snippets/cubeMeshSigNeur.py:146 
    ./Demos/snippets/testSigNeur.py:259 
    ./python/moose/multiscale/core/mumbl.py:206 
    ./Demos/snippets/multiComptSigNeur.py:268 
    

    e voilà, genera il percorso dei file corrispondenti e il numero di linea a cui la partita è stata trovata. se è stata trovata più di una corrispondenza, ogni numero di linea verrà aggiunto al nome del file.

  8. per cercare la stringa e l'output basta quella linea con la stringa di ricerca:

    for i in $(find /path/of/target/directory -type f); do grep -i "the string to look for" "$i"; done
    

    ad es. per esempio ::::

    for i in $(find /usr/share/applications -type f); \
    do grep -i "web browser" "$i"; done
    

    per visualizzare filename contenente la stringa di ricerca:

    for i in $(find /path/of/target/directory -type f); do if grep -i "the string to look for" "$i" > /dev/null; then echo "$i"; fi; done;
    

    ad es. per esempio ::::

    for i in $(find /usr/share/applications -type f); \
    do if grep -i "web browser" "$i" > /dev/null; then echo "$i"; \
    fi; done;
    
    1. vedo solo un aspetto negativo rispetto all'utilizzo di find … -exec grep 'str' {} \; (se si deve usare find a tutti).
    1. ciò si infrangerebbe orribilmente se uno qualsiasi dei file trovati da find spazi contenuti.. si potrebbe finire grepping i file errati e / o mancanti i file giusti del tutto. basta usare find ... -exec grep ... se si ha la necessità di utilizzare find.. ma in questo caso un grep -r ... basta.
    1. qual è il punto di utilizzare un ciclo sopra i risultati della ricerca per poi grep? questo diventa inutilmente complicato.
  9. qui ci sono diversi elenco di comandi che possono essere utilizzati per la ricerca di file.

    grep "text string to search” directory-path
    
    grep [option] "text string to search” directory-path
    
    grep -r "text string to search” directory-path
    
    grep -r -H "text string to search” directory-path
    
    egrep -R "word-1|word-2” directory-path
    
    egrep -w -R "word-1|word-2” directory-path
    
    1. @fedorqui egrep equivale a grep -E e significa --extended-regexp si possono trovare i dettagli qui https://unix.stackexchange.com/a/17951/196072
  10. è possibile utilizzare:

    grep -r "string to be searched"  /path/to/dir
    

    il r sta per ricorsivo e quindi cercherà nel percorso specificato ed anche nelle sue sottodirectory. questo vi dirà il nome del file così come stampare la linea nel file in cui la stringa appare.

    o un comando simile a quello che stai cercando (esempio:) per la ricerca in tutti i file javascript (* .js):

    find . -name '*.js' -exec grep -i 'string to search for' {} \; -print
    

    questo stamperà le righe nei file in cui il testo appare, ma non stampa il nome del file.

    in aggiunta a questo comando, possiamo scrivere anche questo: grep -rn "String to search" / path / to / directory / or / file -r: ricorsive search n: line number sarà mostrato per matches

    1. grazie per la versione find. la mia versione grep (busybox per NAS) non ha l'opzione -r, avevo davvero bisogno di un'altra soluzione!
    1. grazie per la versione 'find'! è così importante poter filtrare '.js' o '.txt', ecc. nessuno vuole trascorrere ore in attesa di grep per terminare la ricerca di tutti i multi-gigabyte video dell'ultima vacanza in famiglia, anche se il comando è più facile da digitare.
  11. grep può essere utilizzato anche se non siamo alla ricerca di una stringa.

    semplicemente in esecuzione,

    grep -RIl "" .
    

    stamperà il percorso di tutti i file di testo, cioè quelli contenenti solo caratteri stampabili.

  12. se grep non supporta la ricerca ricorsiva, è possibile combinare find con xargs:

    find / -type f | xargs grep 'text-to-find-here'
    

    trovo questo più facile da ricordare che il formato per find -exec.

    questo mostrerà il nome del file e il contenuto della riga corrispondente, ad esempio

    /home/rob/file:text-to-find-here
    

    flag opzionali da aggiungere a grep:

    • -i - ricerca insensibile alle maiuscole
    • -l - visualizza solo il nome del file in cui è stata trovata la corrispondenza
    • -h - visualizza solo la riga che corrisponde (non il nome del file)
    1. questo equivale a grep 'text-to-find-here' senza nome file se find non trova nulla. questo sarà appendere e attendere l'input dell'utente! aggiungere --no-run-if-empty come opzione a xargs.
    1. questa combinazione di find e xargs non funziona come previsto se i nomi di file o directory contengono spazi (caratteri che xargs interpreta come separatori). utilizzare find … -exec grep … +. se insisti nell'usare find insieme con xargs, usa -print0 e -0.
  13. find /path -type f -exec grep -l "string" {} \;
    

    spiegazione dai commenti

    find è un comando che permette di trovare file e altri oggetti come directory e link in sottodirectory di un determinato percorso. se non specifichi una maschera che i nomi dei file dovrebbero incontrare, elenca tutti gli oggetti di directory.

    -type f specifies that it should proceed only files, not directories etc.
    -exec grep specifies that for every found file, it should run grep command, passing its filename as an argument to it, by replacing {} with the filename
    
    1. ciò è realmente un esempio principale di quando non usare xargs come quello. consideri questo. echo "file bar.txt has bar" > bar.txt; echo "file foo bar.txt has foo bar" > "foo bar.txt"; echo "You should never see this foo" > foo; find . -name "*.txt" | xargs grep -i foo # ./foo:You should never see this foo. il xargs qui corrisponde al file FORTE e NON corrisponde al file desiderato. o utilizzare un find .. -print0 | xargs -0 ..., ma che è un uso inutile di un tubo o meglio find ... -exec grep ... {} +
  14. se si dispone di un insieme di file che sarà sempre il controllo è possibile alias i loro percorsi, per esempio:

    alias fd='find . -type f -regex ".*\.\(inc\|info\|module\|php\|test\|install\|uninstall\)"'
    

    poi si può semplicemente filtrare l'elenco come questo:

    grep -U -l $'\015' $(fd)
    

    che filtra l'elenco fd in file che contengono il modello CR.

    trovo che l'aliasing dei file che mi interessa mi aiuta a creare script più facili poi sempre cercando di ricordare come ottenere tutti quei file. la roba ricorsiva funziona pure, ma prima o poi si sta andando a fare i conti con estirpare specifici tipi di file. ecco perché trovo tutti i tipi di file che mi interessano per cominciare.

  15. spero che questo sia di aiuto...

    espandere il grep un po 'per dare maggiori informazioni nell'output, per esempio, per ottenere il numero di linea nel file in cui il testo è può essere fatto come segue:

    find . -type f -name "*.*" -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"
    

    e se hai un'idea del tipo di file puoi restringere la ricerca specificando il tipo di file da cercare, in questo caso .pas O .dfm file:

    find . -type f \( -name "*.pas" -o -name "*.dfm" \) -print0 | xargs --null grep --with-filename --line-number --no-messages --color --ignore-case "searchtext"
    

    breve spiegazione delle opzioni:

    1. . nel find specifica dalla directory corrente.
    2. -name "*.*": per tutti i file (-name "*.pas" -o -name "*.dfm"): solo i file *.pas O *.dfm, O specificati con -o
    3. -type f specifica che si sta cercando di file
    4. -print0 e --null dall'altro lato del | (pipe) sono quelli cruciali, passando il nome del file dal find al grep incluso nel xargs, permettendo il passaggio dei nomi di file CON gli spazi nei nomi dei file, permettendo a grep di trattare il percorso e il nome del file come una stringa, e non spezzarlo su ogni spazio.
    1. -name '*.*' non è quello che si dice; non sarebbe prendere su un file chiamato 'file' perché il modello non equivale a quello (no. ext); * sarebbe comunque (bene. file a parte). ma c'è un'altra cosa: se volete tutti i file perché preoccuparsi di specificare un nome di file, in primo luogo? nessun altro commento - tranne che è bello sapere che ci sono ancora persone che non usano la terminologia MS 'cartella' (che in realtà dopo averlo detto abbastanza non vorrei aggiungere, ma volevo sottolineare l'affermazione leggermente errata che hai fatto con i nomi di file - così come la ridondanza / inutilità nel caso di 'all').
  16. prova: prova:

    find / -type f -exec grep -H 'text-to-find-here' {} \;
    

    che cercherà tutti i file system, perché / è la cartella principale.

    per uso cartella home:

    find ~/ -type f -exec grep -H 'text-to-find-here' {} \;
    

    per l'uso della cartella corrente:

    find ./ -type f -exec grep -H 'text-to-find-here' {} \;
    
    1. forse i particolari sulle differenze dei dispositivi di piegatura sono evidenti a molti... ma anche molto utili per i newbies. + 1 + 1
    1. chiamatela mia crociata, ma la parola è "directory". questo non è Windows (che usato per usare 'directory' comunque - pre 9x). si prega di smettere di dire 'cartella'. per quanto riguarda il tuo ultimo comando non hai nemmeno bisogno del '/' solo FYI.
  17. grep (GNU o BSD)

    è possibile utilizzare grep strumento per cercare ricorsivamente la cartella corrente, come:

    grep -r "class foo" .
    

    nota: -r - ricerca ricorsivamente sottodirectory.

    è inoltre possibile utilizzare la sintassi globbing per cercare all'interno di file specifici come:

    grep "class foo" **/*.c
    

    nota: utilizzando l'opzione globbing (**), esegue la scansione ricorsivamente di tutti i file con estensione o pattern specifici. per abilitare questa sintassi, eseguire: shopt -s globstar. è inoltre possibile utilizzare **/*.* per tutti i file (escluso nascosto e senza estensione) o qualsiasi altro modello.

    se hai l'errore che il tuo argomento è troppo lungo, considerare restringere la ricerca, o utilizzare find sintassi invece come:

    find . -name "*.php" -execdir grep -nH --color=auto foo {} ';'
    

    in alternativa utilizzare ripgrep.

    ripgrep

    se si sta lavorando su progetti più grandi o grandi file, si dovrebbe utilizzare ripgrep invece, come:

    rg "class foo" .
    

    verifica i documenti, i passaggi di installazione o il codice sorgente nella pagina del progetto GitHub.

    e 'molto più veloce di qualsiasi altro strumento come GNU / BSD grep, ucg, ag, sift, ack, pt o simili, dato che è costruito sopra il motore regex di Rust che usa automi finiti, SIMD e ottimizzazioni letterali aggressive per rendere la ricerca molto veloce.

    questo sostiene ignore i modelli specificati in file .gitignore, allora un percorso di file solo può esser abbinato a modelli glob multipli contemporaneamente.


    è possibile utilizzare i parametri comuni come:

    • -i - Ricerca sensibile.
    • -I - Ignora i file binari.
    • -w - Cerca tutte le parole (in contrario alla corrispondenza parziale delle parole).
    • -n - Visualizza la linea della partita.
    • -C / --context (ad esempio -C5) - Aumenta il contesto, in modo da vedere il codice circostante.
    • --color=auto - Seleziona il testo corrispondente.
    • -H - Visualizza il nome del file in cui viene trovato il testo.
    • -c - Visualizza il conteggio delle linee corrispondenti. può essere combinato con -H.
    1. per inalare un intero file system, rg sta andando essere molto meno doloroso di quasi qualsiasi altro strumento.
  18. è possibile utilizzare sotto comando come non si desidera il nome del file, ma si desidera cercare da tutti i file. qui sono io sto catturando "TEXT" forma Tutti i file di log assicurandosi che il nome del file non è stampato

    grep -e TEXT *.log | cut -d' ' --complement -s -f1
    

    grep con l'opzione -e è abbastanza veloce rispetto ad altre opzioni in quanto è per la corrispondenza PATTERN

    1. modo migliore di usare find + grep https://stackoverflow.com/a/51023211/7918560
  19. prova questo

    find . -type f -name some_file_name.xml -exec grep -H PUT_YOUR_STRING_HERE {} \;
    
    1. questo non fornisce una risposta alla domanda. per criticare o richiedere chiarimenti da un autore, lasciare un commento sotto il loro post. - Dalla recensione
    1. @SergeyDenisov Che cosa dà? questa è sicuramente una risposta. (se funziona o meno è un'altra questione.)
    1. @SergeyDenisov. Dà un corso d'azione suggerito che potrebbe produrre il risultato corretto. o, anche se non lo fa, potrebbe aiutare qualcun altro. questo è quello che voglio dire, "E 'una risposta." se volete sapere come funziona, chiedete al poster.
    1. @SireeshYarlagadda Si dovrebbe fornire maggiori informazioni nella vostra risposta, soprattutto perché questo comando è relativamente complicato. suddividetelo in parti e spiegatene ciascuna. (è stato segnalato come bassa qualità perché mancava una spiegazione.)
    1. @jpaugh Sono sicuro che un comando / codice a linea non sia sufficiente per una risposta completa. si potrebbe scrivere un commento dando un corso suggerito di azione, ma una risposta dovrebbe includere una spiegazione. ecco perché questa risposta è stata segnalata come "Low Quality Post" (non da me).
    1. @SergeyDenisov Sono d'accordo con voi su questo! ma non ho capito cosa si intende dal commento "inscatolato" negli strumenti di revisione.
  20. How do I find all files containing specific text on Linux? (...)

    I came across this solution twice:

    find / -type f -exec grep -H 'text-to-find-here' {} \;


    se si utilizza find come nell'esempio, è meglio aggiungere -s (--no-messages) a grep, e 2>/dev/null alla fine del comando per evitare un sacco di messaggi negati Permission emessi da grep e find:

    find / -type f -exec grep -sH 'text-to-find-here' {} \; 2>/dev/null
    

    find è lo strumento standard per la ricerca di file - combinato con grep quando si cerca un testo specifico - su piattaforme Unix-like. il comando find è spesso combinato con xargs, a proposito.

    esistono strumenti più semplici e veloci per lo stesso scopo - vedi sotto. meglio provarli, purché siano disponibili sulla vostra piattaforma, naturalmente:

    alternative più semplici e veloci

    RipGrep - strumento di ricerca più veloce intorno:

    rg 'text-to-find-here' / -l
    

    il cercatore d'argento:

    ag 'text-to-find-here' / -l
    

    ACK: Jack:

    ack 'text-to-find-here' / -l
    

    nota: è possibile aggiungere 2>/dev/null anche a questi comandi, per nascondere molti messaggi di errore.


    attenzione: a meno che non si possa davvero evitare, non cercare da '/' (la directory principale) per evitare una ricerca lunga e inefficiente! quindi negli esempi qui sopra, è meglio sostituire '/' con un nome di sottodirectory, ad esempio "/ home" a seconda di dove si vuole effettivamente cercare...

    1. 'find è lo strumento standard per la ricerca di file contenenti testo specifico su piattaforme Unix-like' mi sembra piuttosto ambiguo. anche oltre alla ricorsiva grep find non cerca direttamente l'interno dei file per il testo. e forse quegli strumenti aggiuntivi sono utili per alcuni ma vecchi timer e quelli whoa sono ben abituati ad esempio grep non avrebbe dato loro in qualsiasi momento a tutti (beh certamente non lo farò). non dicendo che sono inutili però.
  21. il seguente comando funzionerà bene per questo approccio:

    find ./ -name "file_pattern_name"  -exec grep -r "pattern" {} \;
    
    1. qual è il punto di utilizzare find e poi grep -r? sono pensati per lo stesso, quindi questo è ridondante.
    1. Oh!!! corretto, In realtà trovare è per l'esecuzione grep su file filtrati e non tutti, grazie
  22. find … -exec <cmd> + è più facile da digitare e più veloce di find … -exec <cmd> \;. funziona solo se <cmd> accetta qualsiasi numero di argomenti di nome file. il risparmio nel tempo di esecuzione è particolarmente grande se <cmd> è lento per iniziare come script Python o Ruby.
  23. grep -insr "pattern" *
    
    • i: ignora le distinzioni di casi sia nel PATTERN che nei file di input.
    • n: prefisso ogni linea di output con il numero di linea basato su 1 all'interno del file di input.
    • s: sopprimere i messaggi di errore sui file inesistenti o illeggibili.
    • r: leggere tutti i file in ogni directory, ricorsivamente.
    1. potete spiegare come la vostra risposta migliora sulle altre risposte, o come è sufficientemente diversa da esse?
    1. non molto complesso da ricordare, coprirà tutti i modelli (case-sensitivity - > off, include i nomi dei file e il numero di linea e cercherà ricorsivamente ecc.) e usando "*" alla fine cercherà tutte le directory (non è necessario specificare alcun percorso o nome di directory).
    1. spiacente, dovrei essere più chiaro: sarebbe grande se poteste includere quella spiegazione nella vostra risposta. mentre sta, particolarmente con tante altre risposte simili già, è duro vedere da una risposta così corta che cosa il beneficio di provarla sopra la risposta accettata o uno dei upvoted sarebbe.
    1. @AmosM.Carpenter Una cosa che mi piace di questa risposta è sottolineare l'argomento sopprimere, che può aiutare a filtrare il rumore che non importa per ottenere i risultati che realmente vogliamo. grep stampa errori come, "Funzione non implementata", "Argomentazione non valida", "Risorsa non disponibile", ecc. ecc su alcuni "file".
    1. @leetNightshade: Sto assumendo che si sta indirizzando il tuo commento a me, perché ho chiesto una spiegazione sul sparse post originale. si prega di vedere la grande revisione di Fabio per i miei commenti precedenti per avere un senso.
  24. evitare il fastidio e installare ack-grep. elimina un sacco di problemi di permesso e citazione.

    apt-get install ack-grep
    

    poi vai alla directory che vuoi cercare ed eseguire il comando qui sotto

    cd /
    ack-grep "find my keyword"
    
  25. USA pwd per cercare da qualsiasi directory in cui ti trovi, ripetendo verso il basso

    grep -rnw `pwd` -e "pattern"
    

    aggiornamento A seconda della versione di grep che si sta utilizzando, è possibile omettere pwd. nelle versioni più recenti . sembra essere il caso predefinito per grep se nessuna directory è data così:

    grep -rnw -e "pattern"

    o o o o o

    grep -rnw "pattern"

    farà la stessa cosa di sopra!

    1. utilizzare pwd non è affatto necessario, dato che è il default. grep -rnw "pattern" è sufficiente.
    1. e infatti il grep -rnw e simile è quello che è stato risposto come tre anni fa, non vedo come questa risposta è l'aggiunta di valore.
    1. la risposta selezionata non mostra il modello di default, e 5 persone sembravano aver trovato utile
    1. cosa intendi con "default pattern"? la risposta accettata contiene grep -rnw '/path/to/somewhere/' -e "pattern" che è quello che hai qui. 5 voti dopo 2.3m visite non significa molto.
    1. sono d'accordo: -) quello che mi mancava nella risposta originale è il caso d'uso che non si deve dare un percorso a tutti o per cercare ricorsivamente la directory corrente che non si riflette nella risposta accettata. così è stata una buona esperienza di apprendimento su grep a scavare un po 'più profondo.
    1. OK, vedo. non è banale vedere che grep "pattern" ha bisogno di qualcosa da controllare (una dir, un file...) mentre grep -R "pattern" funziona come standalone. allora probabilmente un'aggiunta alla risposta beneficerebbe più gente (gli ultimi alberini sono notati raramente). ma sono contento che avete imparato da esso:) Ho la seconda risposta più votata e vedo che ci sono molte, molte varianti di fare questo.
    1. così con pwd stavo cercando di trovare un hack facile da non digitare nel percorso completo, ma sono sicuro che . sarebbe sufficiente, come directory corrente, ma lasciando fuori del tutto è naturalmente il più magro.
    1. in realtà solo ora sono in esecuzione in problemi dove, se il percorso non è dato, non c'è uscita. così pwd è necessario @fedorqui
    1. cd /tmp; mkdir mytest; cd mytest; mkdir a{1..3}; seq 10 > a1/a1; seq 10 > a1/a2; seq 10 > a2/a1 una volta che hai tutto questo, scrivere grep -rnw 5. questo funziona bene per me su GNU grep 2.16.
  26. per cercare non ricorsivamente in un dato percorso il comando è 'grep --include = & # 42; .txt -snw "pattern" thepath / *.
  27. c'è uno strumento ack che farebbe esattamente quello che stai cercando.

    http://linux.die.net/man/1/ack

    ack -i search_string folder_path/*
    

    si può ignorare -i per la ricerca caso sensibile

    1. che cosa si aggiunge alle risposte esistenti? questo è stato suggerito più di tre anni fa già.
    1. @fedorqui 1) nessuna tubazione! 2) Utilizzare espressioni regolari 3) Ottenere numeri di riga, nome file con percorso relativo, testo evidenziato ecc. utile per la modifica dopo la ricerca ad esempio "vim + lineno path / file.cpp" vi porterà direttamente alla riga no di interesse. vedere l'output del comando "ack include\ | hpp" che cerca "include" o "hpp" parole chiave nella mia cartella di ricerca e sottocartelle. spero che il punto sia chiaro. qui è l'uscita del campione (non può mostrare le punte di parola chiave con testo semplice) il processo / child.hpp 11: spinta / processo / child.hpp processo / all.hpp 21: # include & lt; spinta / processo / execute.hpp >
  28. uso: uso:

    grep -Erni + "text you wanna search"
    

    il comando cerca ricorsivamente in tutti i file e directory della directory corrente e stampa il risultato.

    nota: se l'output di grep non è colorato, puoi modificarlo usando l'alias grep = 'grep --color = always' nel file sorgente della shell.

  29. prova questo:

    find / -type f -name "*" -exec grep -il "String_to_search" {} \;
    

    o o o o o

    for i in /*;do grep -Ril "String_to_search" $i;done 2> /dev/null
    
    1. buona domanda - Iniziamo con le migliori risposte a questa domanda. ho provato di seguito i comandi sul server AIX con più di 15k file nella directory log.

      grep -rnw '/ path / to / da qualche parte /' -e "pattern" > > > ha ottenuto l'errore "/ usr / bin / grep: 0403-027 L'elenco dei parametri è troppo lungo."

      grep -il "text-to-find-here" / > > > ha ottenuto l'errore "/ usr / bin / grep: 0403-027 L'elenco dei parametri è troppo lungo."

      "text-to-find-here '> > > ha ottenuto l'errore" errore di segmentazione (corredump) "

    1. find / -type f -name "*" -exec grep -il "String _ to _ search" {}\; > > produrrà il risultato con nome file e dati file.

      find / -type f -exec grep -H 'text-to-find-here' {}\; > > Essa produrrà il risultato solo con filename.

      per i in / *; fare grep -Ril "String _ to _ search" $i; fare 2 > / dev / null > > funzionerà come grep -Ril "text-to-find-here" / ma supporterà un gran numero di file.

  30. c'è una nuova utility chiamata il Silversearcher

    sudo apt install silversearcher-ag
    

    lavora a stretto contatto con Git e altri VCS. quindi non otterrai nulla in una directory .git o in un'altra.

    si può semplicemente usare

    ag -ia "Search query"
    

    e farà il compito per voi!

  31. @StéphaneLaurent Penso che si sta complicando troppo. basta dire grep "pattern" path/*.txt
  32. uso: uso:

    grep -c Your_Pattern *
    

    questo segnalerà quante copie del vostro modello ci sono in ciascuno dei file nella directory corrente.

  33. è possibile utilizzare i seguenti comandi per trovare un particolare testo da un file:

    cat file | grep 'abc' | cut -d':' -f2
    
    1. la domanda è di trovare quali file contengono una stringa, non di trovare una stringa in un file.
  34. un Simple find può funzionare a portata di mano. alias nel file ~/.bashrc:

    alias ffind find / -type f | xargs grep
    

    avviare un nuovo terminale ed emettere:

    ffind 'text-to-find-here'
    
  35. tutte le risposte precedenti suggeriscono grep e trovare. ma c'è un altro modo: USA Midnight Commander

    è un'utilità libera (30 anni, provata da tempo) che è visiva senza essere GUI. ha tonnellate di funzioni, e trovare file è solo uno di loro.

  36. sono affascinato da come grep semplice rende con 'rl'

    grep -rl 'pattern_to_find' /path/where/to/find
    
    -r to find recursively file / directory inside directories..
    -l to list files matching the 'pattern'
    

    Use '-r' without 'l' to see the file names followed by text in which the pattern is found!

    grep -r 'pattern_to_find' /path/where/to/find
    

    funziona solo perfetto..

    spero che aiuti!

    1. ma implica ogni file deve cercato (nessun filtro sul nome file o livello di estensione del file, come .txt). o c'è un modo per farlo?
  37. Grep è il tuo buon amico per raggiungere questo obiettivo.

    grep -r <text_fo_find> <directory>
    

    se non ti interessa il caso del testo per trovare quindi utilizzare

    grep -ir <text_to_find> <directory>
    
    1. @Pathros Probabilmente a che fare con la ricorsione abilitato e quale directory si specifica. in un altro modo la ricorsione cambia le cose in questo modo.
  38. find con xarg s è preferito quando ci sono molte partite potenziali per passare al setaccio. funziona più lentamente di altre opzioni, ma funziona sempre. come alcuni hanno scoperto, xargs non gestisce i file con spazi incorporati per impostazione predefinita. è possibile superare questo problema specificando l'opzione -d.

    ecco la risposta @RobEarl's, migliorata in modo da gestire i file con spazi:

    find / -type f | xargs -d '\n' grep 'text-to-find-here'
    

    ecco la risposta @venkat's, allo stesso modo migliorato:

    find . -name "*.txt" | xargs -d '\n' grep -i "text_pattern"
    

    ecco la risposta di van Biljon, ugualmente migliorata:

    find . -type f -name "*.*" -print0 | xargs -d '\n' --null grep --with-filename --line-number --no-messages --color --ignore-case "searthtext"
    

    ecco la risposta @LetalProgrammer's, allo stesso modo migliorato:

    alias ffind find / -type f | xargs -d '\n' grep
    

    ecco la risposta di Hussain, ugualmente migliorata:

    find . | xargs -d '\n' grep 'word' -sl
    
    1. "sotto molti altri sistemi Unix-like, liste arbitrariamente lunghe di parametri non possono essere passate ad un comando, quindi il comando può fallire con un messaggio di errore di" Argent list too long "(il che significa che il limite della chiamata di sistema exec sulla lunghezza di una linea di comando è stato superato)"... https://en.wikipedia.org/wiki/Xargs
  39. alternativa alla ricerca GUI - Per l'utilizzo desktop:

    - Poiché la domanda non è precisamente chiedere comandi

    Searchmonkey: avanzato strumento di ricerca di file senza dover indicizzare il sistema utilizzando espressioni regolari. grafica equivalente a find / grep. disponibile per Linux (Gnome / KDE / Java) e Windows (Java) - open source GPL v3

    caratteristiche:

    • espressioni regolari avanzate
    • risultati mostrati in contesto
    • ricerca contenente testo
    • pannello per visualizzare la linea contenente testo
    • nuovi aggiornamenti 2018
    • ecc.

    download - Links:

    ....

    screen-shot:

    Enter image description here

  40. se si desidera utilizzare rigorosamente find allora:

    find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

    find + grep

    1.Use find per cercare i file, 2.Then eseguire grep su tutti loro.

    può essere combinato in un unico comando come segue:

    find /path/to/somewhere/ -type f -exec grep -nw 'textPattern' {} \;

    • utilizzare -name Pattern se si desidera grep solo alcuni file:

      find /path/to/somewhere/ -type f -name \*.cpp -exec grep -nw 'textPattern' {} \;

    questo può dare il potere di find per trovare i file. è possibile giocare con esso e utilizzare diverse opzioni di find per migliorare o restringere la ricerca di file.

More similar articles:

  • come cercare interi file di server Linux contenenti testo specifico?
  • come trovare tutti i file contenenti un testo specifico (che include un backslash)?
  • in Linux, come trovo tutti i file contenenti una stringa letterale, anche se la stringa fa parte di una parola composta?
  • come trovare tutti i file contenenti una stringa?
  • come trovare file contenenti una stringa usando egrep
  • come posso trovare file contenenti più modelli
  • server Linux, localizzare file contenenti solo 4 linee specifiche
  • come cercare file contenenti un particolare testo con Ansible?
  • come trovo i file che non contengono un dato modello di stringa?
  • come echeggiare le directory contenenti il file corrispondente con Bash?
  • come trovare tutti i file contenenti un dato file?
  • Linux Script per spostare directory contenenti un file
  • utilizzando find o grep per individuare i nomi dei file con caratteri accentati da un diverso sistema di codifica (da Windows a Linux)
  • trova file non contenenti stringa di ricerca
  • come posso usare grep con tutti i core disponibili?
  • comando Unix per elencare file contenenti stringhe ma * NOT * contenenti un'altra stringa
  • come cercare ricorsivamente i file con determinate estensioni?
  • comando Unix per cercare la stringa di testo in tutti i file
  • come inserire grep in un programma che usa una directory con solo permessi di lettura
  • Linux trova file con stringa e stampa l'ultimo tempo di accesso
  • eliminare i file contenenti "qualche testo" nella cartella con molti file (100k +)
  • 2 file contenenti le stesse stringhe
  • come creare un backup delle linee dei file contenenti "foo"
  • come posso eliminare i file che non sono utilizzati nei file di codice in linux?
  • trova tutti i file modificati di recente (ctime) che non si trovano in directory multiple escluse
  • grep all'interno di tutti i file creati nell'intervallo di date
  • come trovo e sostituisco gli elementi in un file di testo in pyscripter?
  • lo script bash per trovare un testo specifico se sono presenti le stesse linee multple in un file di testo
  • rimuovere l'estremità DOS del carattere di file da molti file in Linux
  • perché grep stampa "No a tale file o directory"?