Come posso trovare tutti i file contenenti testo specifico su Linux?

Sto cercando di trovare un modo per scansionare il mio intero sistema Linux alla ricerca di tutti i file contenenti una specifica stringa di testo. Giusto per chiarire, sto cercando del testo all'interno del file, non nel nome del file.

Quando stavo cercando come fare, 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.

È vicino al modo corretto di farlo? In caso contrario, come dovrei? Questa capacità di trovare stringhe di testo nei file sarebbe straordinariamente utile per alcuni progetti di programmazione che sto realizzando.

Fare quanto segue:

grep -rnw '/path/to/somewhere/' -e 'pattern'

• -ro -Rè ricorsivo,
• -n è il numero di riga e
• -w sta per abbinare l'intera parola.
• -l (L minuscola) può essere aggiunto solo per dare il nome del file dei file corrispondenti.

Insieme a questi, --exclude, --include, --exclude-dirbandiere potrebbero essere utilizzati per la ricerca efficiente:

• Questo cercherà solo attraverso quei file che hanno estensioni .c o .h:

  grep --include=\*.{c,h} -rnw '/path/to/somewhere/' -e "pattern"
  

• Ciò escluderà la ricerca di tutti i file che terminano con l'estensione .o:

  grep --exclude=*.o -rnw '/path/to/somewhere/' -e "pattern"
  

• Per le directory è possibile escludere una o più directory particolari tramite il --exclude-dirparametro. Ad esempio, questo esclude le directory dir1 /, dir2 / e tutte corrispondenti a * .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 del tuo.

Per ulteriori opzioni, controlla man grep.

Puoi usare grep -ilR:

grep -Ril "text-to-find-here" /

• i sta per ignore case (opzionale nel tuo caso).
• R sta per ricorsivo.
• l sta per "mostra il nome del file, non il risultato stesso".
• / sta per iniziare dalla radice della tua macchina.

Puoi usare ack . È come grep per il codice sorgente. Puoi scansionare l'intero file system con esso.

Basta fare:

ack 'text-to-find-here'

Nella tua directory principale.

Puoi anche usare espressioni regolari , specificare il tipo di file, ecc.

AGGIORNARE

Ho appena scoperto The Silver Searcher , che è come ack ma 3-5 volte più veloce di esso e ignora persino i pattern di un .gitignorefile.

Puoi usare:

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

Lo rsta per ricorsivo e quindi cercherà nel percorso specificato e anche nelle sue sottodirectory. Questo ti dirà il nome del file e stampa la riga nel file in cui appare la stringa.

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

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

Ciò stamperà le linee nei file in cui appare il testo, ma non stampa il nome del file.

Oltre a questo comando, possiamo scrivere anche questo: grep -rn "String to search" / path / to / directory / o / file -r: ricerca ricorsiva n: il numero di riga verrà mostrato per le corrispondenze

Puoi usare questo:

grep -inr "Text" folder/to/be/searched/

Elenco di nomi di file contenenti un determinato testo

Prima di tutto, credo che tu abbia usato -Hinvece di -l. Puoi anche provare ad aggiungere il testo tra virgolette seguito da {} \.

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

Esempio

Supponiamo che tu stia cercando file contenenti il ​​testo specifico "Licenza Apache" all'interno della tua directory. Visualizzerà risultati in qualche modo simili a quelli di seguito (l'output sarà diverso in base al contenuto della directory).

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 la sensibilità del case

Anche se non si utilizza il caso come "testo" vs "TESTO", è possibile utilizzare l' -iinterruttore per ignorare il caso. Puoi leggere ulteriori dettagli qui .

Spero che questo ti aiuti.

grep( GNU o BSD )

Puoi usare lo grepstrumento per cercare ricorsivamente la cartella corrente, come:

grep -r "class foo" .

^{Nota: -r- Cerca ricorsivamente le sottodirectory.}

Puoi anche usare la sintassi globbing per cercare all'interno di file specifici come:

grep "class foo" **/*.c

^{Nota: utilizzando l' opzione globbing ( **), esegue la scansione di tutti i file in modo ricorsivo con estensione o modello specifici. Per abilitare questa sintassi, eseguire: shopt -s globstar. È inoltre possibile utilizzare **/*.*per tutti i file (esclusi quelli nascosti e senza estensione) o qualsiasi altro motivo.}

Se hai l'errore che l'argomento sia troppo lungo, considera di restringere la ricerca o usa la findsintassi invece come:

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

In alternativa usa ripgrep.

ripgrep

Se stai lavorando su progetti più grandi o file di grandi dimensioni, dovresti ripgrepinvece utilizzare , come:

rg "class foo" .

^{Controlla i documenti, i passaggi di installazione o il codice sorgente nella pagina del progetto GitHub .}

È molto più veloce di qualsiasi altro strumento come GNU / BSD grep , ucg, ag, sift, ack, pto simili, dal momento che è costruito sulla cima di motore regex di Rust , che utilizza automi a stati finiti, SIMD e ottimizzazioni letterali aggressivi per rendere la ricerca molto veloce.

Supporta i pattern ignorati specificati nei .gitignorefile, quindi un singolo percorso di file può essere abbinato contemporaneamente a più pattern glob.

È possibile utilizzare i parametri comuni come:

• -i - Ricerca insensibile.
• -I - Ignora i file binari.
• -w - Cerca le parole intere (al contrario della corrispondenza parziale delle parole).
• -n - Mostra la linea della tua partita.
• -C/ --context(ad es. -C5): aumenta il contesto, in modo da visualizzare il codice circostante.
• --color=auto - Contrassegna il testo corrispondente.
• -H - Visualizza il nome del file in cui è stato trovato il testo.
• -c- Visualizza il conteggio delle righe corrispondenti. Può essere combinato con -H.

Se il tuo grepnon supporta la ricerca ricorsiva, puoi combinare findcon xargs:

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

Trovo questo più facile da ricordare rispetto al formato per find -exec .

Ciò genererà il nome file e il contenuto della riga corrispondente, ad es

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

Flag facoltativi che potresti voler aggiungere a grep:

• -i - ricerca senza distinzione tra maiuscole e minuscole
• -l - genera solo il nome del file in cui è stata trovata la corrispondenza
• -h - produce solo la riga corrispondente (non il nome del file)

grep -insr "pattern" *

• i: Ignora le distinzioni maiuscole e minuscole sia nel PATTERN sia nei file di input.
• n: Prefigura ciascuna riga dell'output con il numero di riga basato su 1 all'interno del suo file di input.
• s: Elimina i messaggi di errore relativi a file inesistenti o illeggibili.
• r: Leggi tutti i file in ciascuna directory, in modo ricorsivo.

C'è una nuova utility chiamata The Silversearcher

sudo apt install silversearcher-ag

Funziona a stretto contatto con Git e altri VCS. Quindi non otterrai nulla in un .git o in un'altra directory.

Puoi semplicemente usare

ag "Search query"

E farà il compito per te!

Come posso trovare tutti i file contenenti testo specifico su Linux? (...)

Mi sono imbattuto in questa soluzione due volte:

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

Se si utilizza find come nel tuo esempio, meglio aggiungere -s( --no-messages) a grep, e 2>/dev/nullalla fine del comando a un sacco Evitare di permesso negato messaggi emessi da grepe 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 simili a Unix. Ilcomando find è spesso combinato con xargs proposito, il .

Esistono strumenti più veloci e più facili per lo stesso scopo - vedi sotto. Meglio provarli, a condizione che siano disponibili sulla tua piattaforma , ovviamente:

Alternative più veloci e più facili

RipGrep - lo strumento di ricerca più veloce in circolazione:

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

The Silver Searcher :

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

ack :

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

Nota: è possibile aggiungere anche 2>/dev/nulla questi comandi, per nascondere molti messaggi di errore.

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

Provare:

find . -name "*.txt" | xargs grep -i "text_pattern"

Utilizzare pwdper cercare da qualsiasi directory ci si trovi, ricorrendo verso il basso

grep -rnw `pwd` -e "pattern"

Aggiornamento A seconda della versione di grep in uso, è possibile omettere pwd. Nelle versioni più recenti .sembra essere il caso predefinito per grep se non viene fornita alcuna directory:

grep -rnw -e "pattern"

o

grep -rnw "pattern"

farà la stessa cosa di cui sopra!

grep può essere utilizzato anche se non stiamo cercando una stringa.

Semplicemente correndo,

grep -RIl "" .

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

Ecco i vari elenchi di comandi che possono essere utilizzati per cercare 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

Silver Searcher è uno strumento eccezionale, ma ripgrep potrebbe essere ancora migliore.

Funziona su Linux, Mac e Windows ed è stato scritto su Hacker News un paio di mesi fa (questo ha un link al Blog di Andrew Gallant che ha un link GitHub):

Ripgrep - Un nuovo strumento di ricerca della riga di comando

find /path -type f -exec grep -l "string" {} \;

Spiegazione dai commenti

find è un comando che ti consente di trovare file e altri oggetti come directory e collegamenti nelle sottodirectory di un determinato percorso. Se non si specifica una maschera che i nomi file devono soddisfare, enumera tutti gli oggetti 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

Provare:

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

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

Per l'uso della cartella home:

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

Per la cartella corrente utilizzare:

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

Spero che questo sia di aiuto ...

Espandendo grepun po 'per fornire ulteriori informazioni nell'output, ad esempio per ottenere il numero di riga nel file in cui si trova il testo, è possibile:

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

E se hai idea di quale sia il tipo di file, puoi restringere la ricerca specificando le estensioni del tipo di file da cercare, in questo caso .pasO i .dfmfile:

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 findspecifica dalla directory corrente.
2. -name" *.*": Per tutti i file (-name " *.pas" -o -name " *.dfm"): solo i *.pasOR *.dfmfile, oppure specificato con-o
3. -type f specifica che stai cercando file
4. -print0e --nulldall'altro lato del |(pipe) ci sono quelli cruciali, passando il nome del file dal findal grepincorporato nel xargs, permettendo il passaggio di nomi di file CON spazi nei nomi di file, permettendo a grep di trattare il percorso e il nome del file come una stringa, e non romperlo su ogni spazio.

Un semplice findpuò funzionare a portata di mano. alias nel tuo ~/.bashrcfile:

alias ffind find / -type f | xargs grep

Avvia un nuovo terminale ed emetti:

ffind 'text-to-find-here'

Ho scritto uno script Python che fa qualcosa di simile. Ecco 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, .corrisponde anche a newline.

Il terzo argomento file_pattern, è facoltativo. Questa è un'altra espressione regolare che funziona su un nome file. Verranno considerati solo i file che corrispondono a questa espressione regolare.

Ad esempio, se voglio cercare i file Python con l'estensione pycontenente Pool(seguita da word 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 riga in cui è stata trovata la corrispondenza. Se viene trovata più di una corrispondenza, ogni numero di riga verrà aggiunto al nome file.

Se si desidera utilizzare rigorosamente, findutilizzare find + grep:

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

passaggi:

1.Utilizzare findper cercare i file,
2. Quindi eseguire grepsu tutti.

Questo può darti il ​​potere di findtrovare i file.

• Utilizzare -name Patternse si desidera grepsolo determinati file:

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

Puoi giocarci e usare diverse opzioni findper migliorare o restringere la ricerca dei file.

Uso:

grep -c Your_Pattern *

Questo riporterà quante copie del tuo modello ci sono in ciascuno dei file nella directory corrente.

grep è il tuo buon amico per raggiungere questo obiettivo.

grep -r <text_fo_find> <directory>

Se non ti interessa il caso del testo da trovare, usa:

grep -ir <text_to_find> <directory>

Sono affascinato da quanto semplice grep lo faccia con 'rl':

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

-r to recursively find a file / directory inside directories..
-l to list files matching the 'pattern'

Usa '-r' senza 'l' per vedere i nomi dei file seguiti dal testo in cui si trova lo schema !

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

Funziona perfettamente ...

Per cercare la stringa e generare solo quella riga 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

per esempio:

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

Per visualizzare il nome file 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;

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;

C'è uno ackstrumento che farebbe esattamente quello che stai cercando.

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

ack -i search_string folder_path/*

È possibile ignorare la -iricerca con distinzione tra maiuscole e minuscole

Tutte le risposte precedenti suggeriscono grep e find. Ma c'è un altro modo: Usa Midnight Commander

È un'utilità gratuita (30 anni, comprovata dal tempo) che è visiva senza essere una GUI. Ha un sacco di funzioni e la ricerca di file è solo una di queste.

Il comando seguente funzionerà bene per questo approccio:

find ./ -name "file_pattern_name"  -exec grep -r "pattern" {} \;

Evita il fastidio e installa ack-grep. Elimina molti problemi di autorizzazione e quotazione.

apt-get install ack-grep

Quindi vai alla directory che desideri cercare ed esegui il comando di seguito

cd /
ack-grep "find my keyword"