Quando si tratta di individuare file o directory sul sistema, il comando find su Linux non ha eguali. È semplice da usare, ma ha molte opzioni diverse che ti consentono di perfezionare la tua ricerca di file.
Continua a leggere per vedere esempi di come utilizzare questo comando per trovare qualsiasi cosa sul tuo sistema. Ogni file è a pochi tasti di distanza una volta che sai come usare il comando trova in Linux.
Trova una directory
Puoi dire al comando find di cercare in modo specifico le directory con l'opzione -type d. Questo farà in modo che il comando di ricerca cercherà solo i nomi di directory corrispondenti e non i nomi di file.
$ find /path/to/search -type d -name "name-of-dir"
Trova file nascosti
Poiché i file e le directory nascosti in Linux iniziano con un punto, possiamo specificare questo modello di ricerca nella nostra stringa di ricerca per elencare in modo ricorsivo i file e le directory nascosti.
$ find /path/to/search -name ".*"
Trova file di una certa dimensione o maggiore di X
L'opzione -size su trova ci consente di cercare file di una dimensione specifica. Può essere utilizzato per trovare file di dimensioni esatte, file più grandi o più piccoli di una determinata dimensione o file che rientrano in un intervallo di dimensioni specificato. Ecco alcuni esempi:
Cerca file di dimensioni superiori a 10 MB:
$ find /path/to/search -size +10M
Cerca file di dimensioni inferiori a 10 MB:
$ find /path/to/search -size -10M
Cerca file di dimensioni esatte di 10 MB:
$ find /path/to/search -size 10M
Cerca file di dimensioni comprese tra 100 MB e 1 GB:
$ find /path/to/search -size +100M -size -1G
Trova da un elenco di file
Se hai un elenco di file (in un file .txt, ad esempio) che devi cercare, puoi cercare il tuo elenco di file con una combinazione dei comandi find e grep. Affinché questo comando funzioni, assicurati che ogni modello che desideri cercare sia separato da una nuova riga.
$ find /path/to/search | grep -f filelist.txt
L'opzione -f su grep significa "file" e ci permette di specificare un file di stringhe da abbinare. Ciò comporta il comando find che restituisce qualsiasi nome di file o directory che corrisponda a quelli nell'elenco.
Non trova in un elenco
Utilizzando lo stesso elenco di file menzionato nell'esempio precedente, puoi anche utilizzare il comando trova per cercare tutti i file che non adatta i modelli all'interno del file di testo. Ancora una volta, useremo una combinazione del comando find e grep; abbiamo solo bisogno di un'opzione aggiuntiva specificata con grep:
$ find /path/to/search | grep -vf filelist.txt
L'opzione -v su grep significa "corrispondenza inversa" e restituirà un elenco di file che non corrispondono a nessuno dei modelli specificati nel nostro elenco di file.
Imposta la profondità massima
Il comando trova cercherà ricorsivamente per impostazione predefinita. Ciò significa che cercherà nella directory specificata il modello specificato, nonché in tutte le sottodirectory all'interno della directory in cui hai detto di cercare.
Ad esempio, se dici a find di cercare nella directory principale di Linux (/), cercherà nell'intero disco rigido, indipendentemente dal numero di sottodirectory di sottodirectory esistenti. Puoi aggirare questo comportamento con l'opzione -maxdepth.
Specificare un numero dopo -maxdepth per indicare a find su quante sottodirectory dovrebbe cercare ricorsivamente.
Cerca i file solo nella directory corrente e non cercare in modo ricorsivo:
$ find . -maxdepth 0 -name "myfile.txt"
Cerca i file solo nella directory corrente e una sottodirectory più in profondità:
$ find . -maxdepth 1 -name "myfile.txt"
Trova file vuoti (lunghezza zero)
Per cercare file vuoti con trova, puoi usare il flag -empty. Cerca tutti i file vuoti:
$ find /path/to/search -type f -empty
Cerca tutte le directory vuote:
$ find /path/to/search -type d -empty
È anche molto utile accoppiare questo comando con l'opzione -delete se desideri eliminare automaticamente i file o le directory vuoti restituiti da trova.
Elimina tutti i file vuoti in una directory (e sottodirectory):
$ find /path/to/search -type f -empty -delete
Trova la directory o il file più grande
Se desideri determinare rapidamente quali file o directory sul tuo sistema occupano più spazio, puoi utilizzare trova per cercare ricorsivamente e generare un elenco ordinato di file e/o directory in base alla loro dimensione.
Come mostrare il file più grande in una directory:
$ find /path/to/search -type f -printf "%s\t%p\n" | sort -n | tail -1
Si noti che il comando find è stato ordinato in base ad altre due utili utilità Linux:sort e tail. Il comando Sort metterà in ordine l'elenco dei file in base alla loro dimensione e il comando tail produrrà solo l'ultimo file nell'elenco, che è anche il più grande.
Puoi regolare il comando tail se desideri produrre, ad esempio, i primi 5 file più grandi:
$ find /path/to/search -type f -printf "%s\t%p\n" | sort -n | tail -5
In alternativa, puoi usare il comando head per determinare i file più piccoli:
$ find /path/to/search -type f -printf "%s\t%p\n" | sort -n | head -5
Se desideri cercare directory anziché file, specifica semplicemente "d" nell'opzione del tipo. Come mostrare la directory più grande:
$ find /path/to/search -type d -printf "%s\t%p\n" | sort -n | tail -1
Trova i file dei set di setuid
Setuid è l'abbreviazione di "imposta l'ID utente durante l'esecuzione", che è un'autorizzazione file che consente a un utente normale di eseguire un programma con privilegi elevati (come root).
Questo può essere un problema di sicurezza per ovvi motivi, ma è facile isolare questi file con il comando trova e alcune opzioni.
Il comando trova ha due opzioni per aiutarci a cercare i file con determinate autorizzazioni:-user e -perm. Per trovare file che possono essere eseguiti con privilegi di root da un utente normale, puoi usare questo comando:
$ find /path/to/search -user root -perm /4000
Nello screenshot sopra, abbiamo incluso l'opzione -exec per mostrare un po' più di output sui file con cui trova i ritorni. L'intero comando è simile a questo:
$ find /path/to/search -user root -perm /4000 -exec ls -l {} \; Puoi anche sostituire "root" in questo comando per qualsiasi altro utente che desideri cercare come proprietario. Oppure puoi cercare tutti i file con autorizzazioni SUID e non specificare affatto un utente:
$ find /path/to/search -perm /4000
Trova i file sgid set
Trovare file con SGID impostato è quasi come trovare file con SUID, tranne per il fatto che i permessi per 4000 devono essere cambiati in 2000:
$ find /path/to/search -perm /2000
Puoi anche cercare file con SUID e SGID impostati specificando 6000 nell'opzione permessi:
$ find /path/to/search -perm /6000
Elenca i file senza autorizzazione negata
Durante la ricerca di file con il comando trova, è necessario disporre delle autorizzazioni di lettura per le directory e le sottodirectory in cui si sta effettuando la ricerca. In caso contrario, find genererà un messaggio di errore ma continuerà a cercare nelle directory per le quali disponi dell'autorizzazione.
Sebbene ciò possa accadere in molte directory diverse, accadrà sicuramente durante la ricerca nella directory principale.
Ciò significa che quando stai cercando un file nell'intero disco rigido, il comando trova produrrà un sacco di messaggi di errore.
Per evitare di vedere questi errori, puoi reindirizzare l'output stderr di find su stdout e reindirizzarlo a grep.
$ find / -name "myfile.txt" 2>%1 | grep -v "Permission denied"
Questo comando usa l'opzione -v (inversa) di grep per mostrare tutto l'output tranne le righe che dicono "Autorizzazione negata".
Trova i file modificati negli ultimi X giorni
Utilizzare l'opzione -mtime sul comando find per cercare file o directory che sono stati modificati negli ultimi X giorni. Può anche essere utilizzato per cercare file più vecchi di X giorni o file che sono stati modificati esattamente X giorni fa.
Ecco alcuni esempi di come utilizzare l'opzione -mtime nel comando trova:
Cerca tutti i file che sono stati modificati negli ultimi 30 giorni:
$ find /path/to/search -type f -mtime -30
Cerca tutti i file che sono stati modificati più di 30 giorni fa:
$ find /path/to/search -type f -mtime +30
Cerca tutti i file che sono stati modificati esattamente 30 giorni fa:
$ find /path/to/search -type f -mtime 30
Se vuoi che il comando find restituisca maggiori informazioni sui file che trova, come la data di modifica, puoi usare l'opzione -exec e includere un comando ls:
$ find /path/to/search -type f -mtime -30 -exec ls -l {} \; Ordina per ora
Per ordinare i risultati di find in base all'ora modificata dei file, puoi utilizzare l'opzione -printf per elencare i tempi in modo ordinabile e reindirizzare l'output all'utilità di ordinamento.
$ find /path/to/search -printf "%T+\t%p\n" | sort
Questo comando ordinerà i file più vecchi in quelli più recenti. Se desideri che i file più recenti vengano visualizzati per primi, passa semplicemente l'opzione -r (indietro) per ordinare.
$ find /path/to/search -printf "%T+\t%p\n" | sort -r
Differenza tra individua e trova
Il comando locate su Linux è un altro buon modo per cercare file sul tuo sistema. Non è ricco di una pletora di opzioni di ricerca come il comando trova, quindi è un po' meno flessibile, ma è comunque utile.
$ locate myfile.txt
Il comando locate funziona cercando in un database che contiene tutti i nomi dei file nel sistema. Il comando updateb aggiorna questo database.
Poiché il comando locate non deve eseguire una ricerca in tempo reale di tutti i file sul sistema, è molto più efficiente del comando find. Ma oltre alla mancanza di opzioni, c'è un altro inconveniente:il database dei file si aggiorna solo una volta al giorno.
Puoi aggiornare questo database di file manualmente eseguendo il comando updateb:
$ updatedb
Il comando locate è particolarmente utile quando devi cercare un file nell'intero disco rigido poiché il comando find richiederà naturalmente molto più tempo, poiché deve attraversare ogni singola directory in tempo reale.
Se stai cercando una directory specifica, nota per non contenere un numero elevato di sottodirectory, è meglio attenersi al comando trova.
Carico CPU del comando trova
Durante la ricerca in un sacco di directory, il comando find può richiedere molte risorse. Dovrebbe intrinsecamente consentire ai processi di sistema più importanti di avere la priorità, ma se devi assicurarti che il comando find occupi meno risorse su un server di produzione, puoi usare il comando ionice o nice.
Monitora l'utilizzo della CPU del comando trova:
$ top
Riduci la priorità di input/output del comando trova:
$ ionice -c3 -n7 find /path/to/search -name "myfile.txt"
Riduci la priorità della CPU del comando trova:
$ nice -n 19 find /path/to/search -name "myfile.txt"
Oppure combina entrambe le utilità per garantire davvero un basso I/O e una bassa priorità della CPU:
$ nice -n 19 ionice -c2 -n7 find /path/to/search -name "myfile.txt"
Spero che il tutorial ti sia utile. Continua a tornare.