Come usare Grep per cercare in modo ricorsivo

L'istruzione "grep" è stata molto conosciuta tra gli utenti di Linux per le sue funzionalità di ricerca. La query "grep" funziona in modo diverso mentre utilizzata con flag diverse per la ricerca ricorsiva. Il flag più usato del comando grep è "-r" che implica cercare nella directory corrente. Facciamo alcuni esempi di una ricerca ricorsiva in Ubuntu 20.04 Utilizzo del comando Grep. Inizia dall'avvio dell'applicazione del terminale tramite il tasto di scelta rapida "Ctrl+alt+T".

Cerca senza percorso di directory

Il modo più semplice e semplice per la ricerca ricorsiva è utilizzare un semplice flag "-r" all'interno del comando GREP e un modello di corrispondenza senza alcun percorso menzionato. Abbiamo usato il comando Grep per cercare un modello "John" all'interno dei file. Il flag "-r" cercherà tutti i file situati all'interno della directory di casa o corrente di Ubuntu 20.04 e anche nelle sottocartelle della home directory. Puoi vedere che mostra i percorsi del file che hanno la corrispondenza particolare e visualizza anche il testo abbinato all'interno di quel file. I primi due file si trovano all'interno della sottodirectory dei documenti della cartella domestica, mentre gli altri due si trovano nella directory della casa. Ciò significa che ha cercato anche da ogni sottocartella della directory corrente.

$ grep -r "John"

Cerchiamo ricorsivamente un'altra parola, "cuore" utilizzando l'istruzione Grep con la flag "-r". L'output del comando mostra che è stato trovato nei due file. Un file risiede all'interno della home directory mentre l'altro è nella sottodirectory di casa, i.e., Documenti. Entrambi i file contengono lo stesso nome.

$ grep -r "cuore"

Diamo un'occhiata a un'altra stessa istanza con un modello di corrispondenza diverso all'interno del comando GREP. Quindi abbiamo usato il pattern "CSS" per essere cercati dal sistema in modo ricorsivo.

$ grep -r "css"

Un altro modo è utilizzare il segno "*" per cercare in tutte le cartelle e sottocartelle. Quindi, abbiamo perquisito il personaggio semplice "A" e l'abbiamo trovato in ogni file di testo della home directory e delle sue sottocartelle.

$ grep -r "a" *

Facciamo una ricerca ricorsiva usando il comando Grep ma in modo diverso. Cercheremo uno schema mentre il testo nei file non verrà visualizzato nel terminale usando il flag "-l" nell'istruzione. Solo il nome o il percorso del file verranno riportati nell'output che mostra che il modello dato è stato trovato. Quindi, abbiamo provato la stessa domanda con l'aggiunta del flag "-l" per cercare il modello "CSS". Visualizza i file correlati e i loro percorsi nell'output.

$ grep -r -l "css"

Cerca con il percorso di directory

Ora vedremo il funzionamento del comando ricorsivo Grep sul percorso della directory indicata. Quindi, avremo cercato tre diversi schemi all'interno dei "download" sottodirectory della cartella domestica. Il percorso per le cartelle dei download è stato indicato nell'immagine all'interno del comando GREP. Non abbiamo nulla in cambio in quanto il modello non è stato abbinato o trovato.

$ grep -r cdd/home/linux/downloads
$ grep -r css/home/linux/download
$ grep -r poeta/home/linux/download

Cerchiamo un altro modello "è" nella cartella download utilizzando la stessa istruzione. Abbiamo trovato due output per questo modello. L'output visualizza i percorsi del file insieme al testo. Ha anche messo in evidenza il modello abbinato, io.e., "È".

$ grep -r is/home/linux/download

Abbiamo cercato un altro modello, "OK" nella cartella Download e ottenuto solo 1 output in cambio in quanto è abbinato solo a un singolo file.

$ grep -r ok/home/linux/download

Lo stesso modello "OK" è stato cercato dalla diversa sottodirectory questa volta, io.e., Documenti. Il comando GREP non ha restituito nulla in quanto la cartella non contiene alcun file con un particolare modello "OK" al suo interno.

$ grep -r is/home/linux/documenti

Puoi anche cercare in modo ricorsivo il valore della stringa. Quindi, abbiamo fornito l'indirizzo IP come stringa e menzionato il percorso. Questo comando cercherà tutti i file e le cartelle della directory "etc" per cercare nel modello di stringa. L'output mostra un singolo risultato.

$ grep -r “192.168.10.1 " /etc /

Cerca più schemi

Avevamo esaminato gli esempi per cercare il modello singolo usando l'istruzione ricorsiva Grep. Ora vedremo il modo per cercare più modelli anche in modo ricorsivo. Quindi abbiamo utilizzato il comando grep insieme al flag "-rw". Indica che sono avvenute le ricerche multiple. Dopo questa bandiera, puoi menzionare anche il percorso. Lo abbiamo usato senza il percorso per cercare all'interno della directory e delle sue sottocartelle. Il flag "-e" è stato usato qui per indicare il modello singolo. Puoi usare molti flag "-e" in base al numero di schemi che desideri cercare. Abbiamo cercato solo due schemi qui usando "-e". Abbiamo trovato i 4 file nell'output abbinati. Tre file contengono il modello "CSS" e 1 contiene il modello "OK" all'interno.

$ grep -rw -e ok -e css

Puoi anche utilizzare il comando GREP per cercare più schemi all'interno del file specifico. Per questo, devi rimuovere il flag "-rw" dalla query e aggiungere le bandiere "-e" quanto vuoi. Ma devi menzionare il nome del file alla fine, come dimostrato di seguito. Visualizza tutto il testo dal file ed evidenzia il modello di corrispondenza.

$ grep -e "grande" -e "css" -e "is" -e "cuore" nuovo.TXT

Cerca con il flag "include"

La parola chiave Flag Include è stata utilizzata per specificare i tipi di file che vengono cercati solo. Nessun altro file verrà cercato. Quindi, nel primo caso, non siamo riusciti a ottenere nulla.

$ grep -r -include = "*txt" "ok"/home/linux/
$ grep -r -include = "*txt" “Nuovo”/Home/Linux/

Nel nostro secondo caso, abbiamo trovato un singolo output.

Un altro modello, "CSS" è stato usato per la ricerca ricorsiva e ha ottenuto tre risultati, come dimostrato nella foto.

$ grep -r -include = "*txt" "css"/home/linux/

Conclusione

La ricerca ricorsiva è stata dimostrata all'interno di questa guida usando il comando GREP. Il comando "grep" ha usato molte flag per funzionare in modo diverso mentre faceva una ricerca ricorsiva, io.e., "-R" e "include". Il tutorial spiega anche la ricerca ricorsiva con e senza i percorsi della directory indicati nel comando GREP. Pertanto, questo articolo contiene un pacchetto di esempi facili da fare per i suoi utenti per imparare la ricerca ricorsiva più facilmente.