Come usare il comando "grep" per trovare il testo comprese le sottodirectory

Voglio trovare tutti i file che contengono una specifica stringa di testo. Il grepcomando funziona, ma non so come usarlo per ogni directory (posso farlo solo per la mia directory corrente). Ho provato a leggere man grep, ma non ha dato alcun aiuto.

Sarebbe meglio usare

grep -rl "string" /path

dove

• -rL' --recursiveopzione (o ) viene utilizzata per attraversare anche tutte le sottodirectory di /path, mentre
• -lL' --files-with-matchesopzione (o ) viene utilizzata per stampare solo i nomi dei file dei file corrispondenti e non le righe corrispondenti (ciò potrebbe anche migliorare la velocità, dato che grepinterrompere la lettura di un file alla prima corrispondenza con questa opzione).

Se stai cercando le linee corrispondenti nei file, il mio comando preferito è:

grep -Hrn 'search term' path/to/files

• -H causa la stampa del nome file (implicito quando si cercano più file)
• -r fa una ricerca ricorsiva
• -n provoca la stampa del numero di riga

path/to/filespuò essere .quello di cercare nella directory corrente

Ulteriori opzioni che trovo molto utili:

• -Iignora i file binari (complemento: -atratta tutti i file come testo)
• -Ftrattare search termcome un'espressione letterale, non regolare
• -i fare una ricerca senza distinzione tra maiuscole e minuscole

• --color=alwaysper forzare i colori anche durante le tubazioni less. Per creare lesscolori di supporto, è necessario utilizzare l' -ropzione:

  grep -Hrn search . | less -r
  

• --exclude-dir=dirutile per escludere directory come .svne .git.

Credo che tu possa usare qualcosa del genere:

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 specifica che dovrebbe elaborare solo file, non directory ecc.
• -exec grepspecifica che per ogni file trovato, dovrebbe eseguire il comando grep, passando il suo nome file come argomento, sostituendolo {}con il nome file

Il mio comando predefinito è

grep -Rin string *

Uso una R maiuscola perché la lsusa come ricorsiva. Poiché grep accetta entrambi, nessun motivo per non usarlo.

EDIT: per HVNSweeting, apparentemente -Rseguirà symlink dove -rnon lo faranno.

Se sei disposto a provare qualcosa di nuovo, prova ack. Il comando per cercare ricorsivamente la directory corrente stringè:

ack string

L'installazione è abbastanza semplice:

curl http://betterthangrep.com/ack-standalone > ~/bin/ack && chmod 0755 !#:3

(A condizione che tu abbia già la directory ~/bined è preferibilmente nella tua PATH.)

Il comando rgrep è dedicato a tale esigenza

Se non disponibile, puoi ottenerlo in questo modo

mkdir -p ~/bin
cd ~/bin
wget http://sdjf.esmartdesign.com/files/rgrep
chmod +x rgrep

Puoi impostare direttamente le opzioni grep predefinite come descritto sopra.

Personalmente uso

[[  ${#args} -lt 5 && "${args//[[:space:]]/}" == "-i" ]] && args="-Hin"
args="${args:--Hns} --color=auto"

argomento correlato: come utilizzare sempre rgrep con il colore

Aggiornamento 2:

Questa riga di comandi utilizza finde greprisolve il problema:

$ find path_to_search_in -type f -exec grep -in searchString {} 2> /dev/null +

--color=<always or auto> per output colorato:

$ find path_to_search_in -type f \
            -exec grep --color=always -in searchString {} 2>/dev/null +

Esempio:

$ find /tmp/test/ -type f -exec grep --color=auto -in "Search string" {} 2>/dev/null +

Un esempio eseguito nell'istantanea di seguito:

Aggiornamento 1:

Puoi provare il seguente codice; come funzione nel tuo .bashrco .bash_aliaseso in uno script:

wherein () 
{ 
    for i in $(find "$1" -type f 2> /dev/null);
    do
        if grep --color=auto -i "$2" "$i" 2> /dev/null; then
            echo -e "\033[0;32mFound in: $i \033[0m\n";
        fi;
    done
}

Uso: wherein /path/to/search/in/ searchkeyword

esempio:

$ wherein ~/Documents/ "hello world"

(Nota: come suggerito nei commenti seguenti di @enzotib, questo non funziona con file / directory inclusi gli spazi nei loro nomi.)

Posta originale

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;

grep( GNU o BSD )

Puoi usare lo grepstrumento per cercare ricorsivamente la cartella corrente con un -rparametro, come:

grep -r "pattern" .

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

Per cercare all'interno di file specifici, è possibile utilizzare una sintassi globbing 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 "pattern" .

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

E 'molto più veloce rispetto a 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 a più pattern glob contemporaneamente.

È 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.

Faccio questo usando xargs, un comando molto sottovalutato

find ./ -type f -print0 | xargs -0 grep 'string_you_are_looking_for'

find ./ ti dà un elenco ricorsivo di tutti i file in una cartella corrente, quindi lo instrada a xargs che esegue il comando grep su ciascuno di quei file

So che ci sono molte risposte qui, ma ecco un'alternativa se desideri aggiungere altre restrizioni durante la ricerca dei file:

find . -type f -exec grep --quiet string_to_look_for {} ';' -print

Questo funziona perché greprestituirà 0 se ha trovato un risultato, 1 altrimenti. Ad esempio puoi trovare file di dimensioni pari a 1 MB e contenenti qualcosa:

find . -type f -exec grep --quiet string_to_look_for {} ';' -size 1M -print

Per molteplici requisiti probabilmente si desidera utilizzare il flag di ottimizzazione -Opresente in GNU grep.

Uno script (trova nel codice) per cercare in C, codice CPP:

#!/bin/sh

find . \( -iname "*.c" -o -iname "*.cpp" -o -iname "*.h" \) -type f -print0 | xargs -0 grep --color -n "$1"

Uso:

find-in-code "search string"