15 esempi super utili del comando Trova in Linux

Il comando trova viene utilizzato per cercare file e directory nella riga di comando di Linux.

Trova è uno dei comandi più potenti e utilizzati di frequente. È anche uno dei comandi più estesi con oltre 50 opzioni e questo lo rende un po' confuso, specialmente quando è abbinato al comando exec o xargs.

È impossibile per un amministratore di sistema o uno sviluppatore di software evitare il comando trova mentre lavora nella riga di comando. Invece di averne paura, dovresti abbracciarne il potere.

Discuterò alcuni degli esempi più comuni del comando find che probabilmente utilizzerai. Ma prima, lascia che ti mostri la sua sintassi e come usarla.

Trova comando in Linux

La sintassi generale per il comando trova è:

find [directory to search] [options] [expression]

Tutto tra parentesi [] è facoltativo. Significa che puoi eseguire find comando senza opzioni e argomenti. Scaricherà semplicemente tutti i file e le directory nella posizione corrente. Non è molto utile, vero?

Diamo un'occhiata più in dettaglio:

• directory to search è fondamentalmente la posizione da cui vuoi iniziare la tua ricerca. Per impostazione predefinita, la ricerca è ricorsiva e inizia dalla tua posizione corrente.
• options specificare il tipo di ricerca, sia per nome, per tipo, per ora modificata, ecc. Sono disponibili più di 50 opzioni qui.
• expression consente di specificare il termine di ricerca. Se vuoi trovare un file in base al suo nome, expression è il nome del file. Se vuoi trovare file il cui nome corrisponde a un modello, espressione nel modello.

Faccio un semplice esempio:

find . -type f -name myfile

Questo comando eseguirà una ricerca nella directory corrente e nelle sue sottodirectory per trovare un file (non directory) chiamato myfile . L'opzione -type f gli chiede di cercare solo i file. Il punto singolo . indica la directory corrente.

Vediamo alcuni esempi pratici del comando trova.

Trova file e directory per nome

Puoi cercare file e directory in base al nome:

find . -name SEARCH_NAME

Poiché non viene menzionato alcun tipo di file, ricerca sia i file che le directory con il nome specificato.

L'esempio seguente trova sia il file che le directory denominate mystuff:

[email protected]:~/Examples$ find -name mystuff
./new/mystuff
./mystuff

Trova solo file o solo directory

Se vuoi solo cercare i file, specifica il tipo di file -f:

find . -type f -name SEARCH_NAME

L'ordine del tipo e del nome non ha importanza. Prendi l'esempio precedente e trova solo per i file:

[email protected]:~/Examples$ find -type f -name mystuff
./mystuff

Se vuoi solo cercare le directory, specifica il tipo -d:

find . -type d -name SEARCH_NAME

Nel file precedente, cerca solo le directory:

[email protected]:~/Examples$ find -type d -name mystuff
./new/mystuff

Esegui una ricerca senza distinzione tra maiuscole e minuscole

Per impostazione predefinita, il comando trova fa distinzione tra maiuscole e minuscole. Puoi eseguire una ricerca senza distinzione tra maiuscole e minuscole con il nome specificato utilizzando -iname invece di -name .

find . -type f -iname SEARCH_NAME

Puoi usarlo con type d anche.

[email protected]:~/Examples$ find -iname mystuff
./new/mystuff
./MyStuff
./mystuff

Screenshot dei tre esempi precedenti:

Cerca i file in base alla loro estensione (importante)

Uno degli usi più comuni del comando trova è trovare file di un tipo specifico o dovrei dire un'estensione specifica.

Ad esempio, supponiamo di voler cercare tutti i file C++ nelle directory correnti. I file C++ terminano con estensione .cpp, quindi puoi cercarli in questo modo:

find . -type f -name "*.cpp"

In questo modo, dici al comando find di cercare type file e con nomi che terminano con .cpp .

[email protected]:~$ find . -type f -name "*.cpp"
./file.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream2/zstream_test.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream/test.cpp
./.cargo/registry/src/github.com-1ecc6299db9ec823/libz-sys-1.1.3/src/zlib/contrib/iostream/zfstream.cpp

Metti sempre l'espressione di ricerca tra virgolette quando usi il comando trova.

Perché consiglio di utilizzare virgolette doppie o virgolette singole attorno al termine di ricerca? Perché se non lo fai, la shell espanderà il carattere jolly.

Se non racchiudi il termine di ricerca tra virgolette:

find . -type f -name *.cpp

La tua shell espanderà *.cpp e lo sostituirà con tutti i file nella directory corrente i cui nomi terminano con .cpp.

Questo potrebbe funzionare se c'è un solo file, ma se ce ne sono più di uno, la tua shell si lamenterà di una sintassi errata.

Nell'esempio sopra, c'è solo un file cpp e quindi quando il comando si espande in find . -type f -name file.cpp , funziona perché file.cpp funziona ancora come termine di ricerca.

Ma ci sono due file .txt nella stessa directory e quindi quando il comando si espande in find . -type f -name another.txt new.txt , si lamenta perché ora c'è più di un termine di ricerca.

Questo è il motivo per cui dovresti sempre racchiudere il termine di ricerca tra virgolette doppie.

Cerca più file con più estensioni (o condizioni)

Il comando precedente ha cercato i file con una determinata estensione. E se volessi cercare file con estensioni diverse?

Invece di eseguire il comando find più volte, eseguilo una volta utilizzando -o opzione che funziona come condizione OR logica:

find . -type f -name "*.cpp" -o -name "*.txt" 

Ecco un esempio:

[email protected]:~/Examples$ find . -type f -name "*.txt" -o -name "*.cpp"
./new.txt
./file.cpp
./new/new.txt
./new/dir2/another.txt
./new/dir1/new.txt
./another.txt

Cerca i file in una directory specifica

Finora, tutti gli esempi eseguiti cercano nella directory corrente perché hai specificato . negli esempi.

Il punto può essere sostituito con un percorso assoluto o relativo di una directory in modo da poter cercare i file nella directory specificata senza lasciare la posizione corrente.

[email protected]:~/Examples$ find ./new -name mystuff 
./new/mystuff

Cerca file in più directory

Se ritieni che i file desiderati possano trovarsi in diverse posizioni, non è necessario eseguire il comando find più volte. Basta specificare tutti i percorsi delle directory da cercare nel comando trova:

find ./location1 /second/location -type f -name "pattern"

Trova file e directory vuoti

Il -empty l'opzione ti consente di cercare file e directory vuoti con il comando trova.

Per trovare tutti i file e le directory vuoti nella directory corrente, usa:

find . -empty

Puoi specificare il tipo di file da cercare solo per file o directory vuoti:

find . -empty -type f

Puoi anche combinarlo con la ricerca del nome del file:

find . -empty -type f -name "*.cpp"

Trova file grandi o piccoli (Cerca in base alla dimensione del file)

Puoi trovare file grandi o file piccoli in base alla ricerca effettuata dal parametro size. Funziona solo con i file, non con le directory.

Usi la -size opzione con +N per taglia maggiore di N e -N per taglia minore di N.

Trova file di dimensioni esatte di 50 KB:

find . -size 50k

Per cercare file di dimensioni superiori a 1 GB nella directory corrente:

find . -size +1G

Per trovare meno di 20 byte:

find . -size -20c

Per trovare file di dimensioni superiori a 100 MB ma inferiori a 2 GB:

find . -size +100M -size -2G

Puoi anche combinare la ricerca per taglia con la ricerca per nome. Ad esempio, per cercare tutti i file il cui nome termina con .log ma di dimensioni maggiori di 500 MB nella directory principale, puoi utilizzare:

find / -size +500M -name "*.log"

Per ricordare:

• c :byte
• k :kilobyte
• M :Megabyte
• G :Gigabyte

Trova i file modificati di recente (Cerca in base al tempo di modifica o creazione)

Conosci il concetto di mtime, atime e ctime, giusto?

• mtime:ora dell'ultima modifica del file
• ctime:ora di creazione del file
• atime:ora dell'ultimo accesso al file

Ti ritroverai spesso in situazioni in cui desideri trovare tutti i file modificati di recente. La ricerca per ora modificata aiuta in questi casi.

Per trovare tutti i file modificati entro 3 giorni (3*24H), utilizzare:

find . -type f -mtime -3

Per trovare tutti i file creati almeno 5 giorni (5*24 ore) fa, utilizza:

find . -type f -ctime +5

So che 24 ore sono un lasso di tempo enorme. Cosa succede se si desidera cercare file che sono stati modificati solo pochi minuti fa? Per questo, puoi usare mmin , amin e cmin .

Per trovare tutti i file che sono stati modificati negli ultimi 5 minuti, usa:

find . -type f -mmin -5

È possibile specificare i limiti superiore e inferiore insieme al nome della ricerca. Il comando seguente cercherà tutti i file .java che sono stati modificati negli ultimi 20-30 minuti.

find . -type f -mmin +20 -mmin -30 -name "*.java"

Trova file con autorizzazioni file specifiche

Spero che tu abbia familiarità con il concetto di autorizzazione dei file in Linux.

Il comando trova consente di cercare file con autorizzazioni file e modalità di accesso specifiche.

find -perm mode

Ad esempio, per trovare tutti i file access mode 777 nella directory corrente;

find . -perm 777

Per trovare tutti i file con accesso in lettura e scrittura per tutti (corrispondenza esatta, non corrisponderà se il file ha il permesso di esecuzione per tutti):

find . -perm a=r+w

Trova i file di proprietà di un utente

Puoi anche cercare i file in base alla proprietà.

Ad esempio, per trovare i file di proprietà dell'utente John nella directory corrente, utilizzare:

find . -type f -user John

Puoi anche combinarlo con altre opzioni come dimensione, ora e nome:

find . -type f -user John -name "*.cpp"

Non trovare ricorsivamente, cerca solo nella directory corrente

Per impostazione predefinita, il comando trova ricerca in tutte le sottodirectory della posizione corrente. Se non lo desideri, puoi specificare la profondità della tua ricerca su 1. Ciò limiterà la ricerca solo alla directory corrente ed escluderà tutte le sottodirectory.

find . -maxdepth 1 -type f -name "*.txt"

Escludi una directory dalla ricerca

se vuoi escludere una directory dalla ricerca, puoi farlo combinando percorso, sfoltimento e logico oppure.

find . -path "./directory_exclude/*" -prune -o -name SEARCH_NAME

Fai attenzione con * nel percorso della directory, -prune dopo il percorso e -o dopo la potatura.

Fondamentalmente, il comando prune chiede di non utilizzare il valore specificato da path. Prune è sempre usato con -o per garantire che il lato destro dei termini venga valutato solo per le directory che non sono state eliminate.

Esegui un'azione sul risultato dei comandi di ricerca (exec e xargs)

Finora, hai imparato vari modi per trovare i file in base a vari criteri. Va bene. Ma puoi migliorarlo eseguendo determinate azioni sul risultato del comando trova.

Ad esempio, che ne dici di trovare file che corrispondono a un determinato modello di nome e rinominarli tutti in una volta o trovare file vuoti ed eliminarli?

Sai che il reindirizzamento della pipe può essere utilizzato per combinare l'output di un comando con l'input di un altro comando. Ma questo non funzionerà con l'output del comando trova, almeno non direttamente.

Hai due opzioni se vuoi eseguire un'azione sul risultato del comando trova:

• Usa exec
• Usa xargs

Utilizzo di trova ed esegui

Si supponga di volere un elenco lungo (ls -l) dei file di ricerca con il comando trova. Ecco cosa usi:

find . -type f -name "*.txt" -exec ls -l {} +

Ecco l'output:

[email protected]:~/Examples$ find . -type f -name "*.txt" -exec ls -l {} +
-rw-rw-r-- 1 abhishek abhishek 39 Oct 13 19:30 ./another.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 15:36 ./new/dir1/new.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 15:36 ./new/dir2/another.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 18:51 ./new/mystuff/new.txt
-rwxrwxrwx 1 abhishek abhishek 35 Oct 13 15:37 ./new/new.txt
-rw-rw-r-- 1 abhishek abhishek 35 Oct 13 18:16 ./new.txt

Molte persone dimenticano di aggiungere il {} + alla fine del comando exec. Devi usarlo e fare attenzione allo spazio tra {} e +.

Il {} è ciò che fa riferimento al risultato del comando find. Puoi immaginare che sia come {file 1, file 2, file 3}. Il + sign viene utilizzato per terminare il comando exec.

Esiste anche un'altra convenzione con exec:

find . -type f -name *.txt" -exec ls -l {} \;

Qui,; viene utilizzato al posto del segno +. Il \prima aggiuntivo; viene utilizzato per sfuggire al carattere speciale;.

Il vantaggio di {} + è che esegue meno comandi come ls -l file1 file2 file3 mentre {} \; eseguirà ls -l file1 , ls -l file2 ecc.

Ma, {} \; ha il vantaggio di utilizzare {} più di una volta nella stessa istruzione exec. Ad esempio, il comando seguente rinominerà tutti i file trovati con estensione .old.

find . -type f -name *.txt" -exec mv {} {}.old \;

Utilizzo di xargs

Molti utenti Linux si abituano al reindirizzamento delle pipe. Questo comando exec con il {} + finale sembra loro intimidatorio.

È qui che aiuta xargs. Basta analizzare l'output del comando find nel comando xargs tramite pipe.

find . -type f -name *.txt" | xargs ls -l

La sintassi sembra molto più semplice, giusto? Anche il comando Xargs è molto potente. Puoi leggerlo qui.

Combinazione di trova e grep

Ora che sai come combinare find con xargs e comando exec, puoi usarlo per combinare find e grep.

Per qualsiasi amministratore di sistema o sviluppatore di software, find e grep è una delle combinazioni più comuni e tuttavia più utili.

Cerchi i pattern dei nomi dei file con find e poi usi grep per cercare il contenuto all'interno di quei file.

Ad esempio, vuoi cercare tutti i file .txt che contengono il termine Alice. Unisci find e grep in questo modo:

find . -type f -name "*.txt" -exec grep -i alice {} +

Lo stesso può essere ottenuto anche con xargs:

find . -type f -name "*.txt" | xargs grep -i alice

Naturalmente, questo è l'esempio più semplice, ma se hai familiarità con il comando grep, puoi usarlo a tuo piacimento e necessità.

C'è molto di più con trova ...

E non è possibile elencare tutte le opzioni e gli esempi del comando trova. Le possibilità sono infinite, ma quando acquisisci familiarità con il comando trova, puoi iniziare a usarlo in una varietà di situazioni. Sta a te decidere come combinare la logica qui.

Spero che questi esempi di comando find siano utili. Se hai ancora domande o suggerimenti per migliorare questo articolo, faccelo sapere nella sezione commenti.