Uso corretto dei comandi Find e Grep in Linux

La maggior parte degli utenti inesperti dei sistemi Unix, in particolare Linux, non hanno familiarità con gli operatori di linea di comando di base utilizzati in questo sistema operativo. Diamo uno sguardo più da vicino alle funzioni e all'uso degli operatori find e grep.

Utilizzo dei comandi Trova e Grep in Linux.

TROVA

Il comando di ricerca di Linux è un'utilità della riga di comando per attraversare la gerarchia dei file. Può essere utilizzato per cercare file e directory ed eseguire operazioni successive con essi. Supporta la ricerca per file, cartella, nome, data di creazione, data di modifica, proprietario e permessi. Usando -exec, altri comandi UNIX possono essere eseguiti per file o cartelle trovati. sintassi:

$ trovare [dove iniziare la ricerca] [espressione determina cosa trovare] [-options] [cosa trovare]

opzioni:

  • -exec: il file richiesto che soddisfa i criteri precedenti e restituisce 0 come stato di uscita per l'esecuzione corretta del comando;
  • -ok - funziona come -exec, tranne che all'utente viene prima richiesto;
  • -inum N - cerca con il numero "N";
  • -links N - cerca con link "N";
  • -name demo - cerca i file specificati in "demo";
  • -newer file - cerca i file che sono stati modificati / creati dopo "file";
  • -perm ottale - cerca se la risoluzione è ottale;
  • -print: mostra il percorso dei documenti trovati usando gli altri criteri;
  • -empty - cerca documenti e directory vuoti;
  • -size + N / -N - cerca i blocchi "N"; "N" e "c" possono essere usati per misurare la dimensione in caratteri; "+ N" significa una dimensione maggiore di blocchi "N" e "-N" significa una dimensione più piccola di blocchi "N";
  • -user name - cerca i documenti che appartengono al nome utente o all'identificatore "nome";
  • \ (expr \) - True se "expr" è vero; Utilizzato per raggruppare i criteri in combinazione con OR o AND.

GREP

Il comando grep viene utilizzato per cercare i file. La funzione sta per "stampa globale di espressioni regolari" ed è uno dei comandi più potenti e usati di frequente in Linux. Il comando cerca uno o più file di input che corrispondono al modello specificato e scrive ciascuna riga corrispondente sullo standard output. Se non vengono specificati file, il comando legge dallo standard input, che di solito è l'output di un altro comando. In questo articolo, ti mostreremo come inserire un comando, con esempi pratici e spiegazioni dettagliate delle più comuni opzioni di grep GNU.

Sintassi del comando

Prima di iniziare a utilizzare il comando, iniziamo esaminando la sintassi di base. Le espressioni di utilità hanno la seguente forma:

[OPZIONI] MODELLO [FILE ...]

Gli articoli tra parentesi quadre sono opzionali.

  • OPZIONI: zero o più scelte. Il team fornisce una serie di opzioni che ne controllano il comportamento.
  • PATTERN - Cerca pattern.
  • FILE: zero o più nomi di file di input.

Come inserire un comando per cercare i file

Lo scopo principale del comando è cercare il testo nel file. Ad esempio, per visualizzare dal file / etc / passwd contenente la riga bash, è possibile utilizzare il seguente comando:

$ grep bash / etc / passwd

L'output dovrebbe essere simile a questo:

root 0: 0: root: / root: / bin / bash

dominio1000: 1000: dominio: / home / dominio: / bin / bash

Se la stringa contiene spazi, è necessario racchiuderla tra virgolette singole o doppie:

$ "Gnome Display Manager" / etc / passwd

Inverti incontro (ex)

Per visualizzare le righe che non corrispondono al modello, inserisci il parametro -v (o -invert-match). Ad esempio, per visualizzare un file che non contiene nologin dal file / etc / passwd, è possibile immettere il seguente comando:

$ -v nologin / etc / passwd

uscita:

root 0: 0: root: / root: / bin / bash

colord 124: 124 :: / var / lib / colord: / bin / false

git 994: 994: git demone utente: /: / usr / bin / git-shell

linuxize 1000: 1000: linuxize: / home / linuxize: / bin / bash

Come usare il comando per cercare nell'output

Invece, se si specificano i file di input, è possibile reindirizzare l'output di un altro comando e quindi visualizzare solo le linee che corrispondono al modello specificato. Ad esempio, per scoprire quali processi sono in esecuzione sul proprio sistema come utente di dati www, è possibile utilizzare il seguente comando:

$ ps -ef | www-data

uscita:

www-data 18247 12675 4 16:00? 00:00:00 php-fpm: piscina www

radice 18272 17714 0 16:00 pts / 0 00:00:00 -color = auto - exclude-dir = .bzr -exclude-dir = CVS -exclude-dir = .git -exclude-dir = .hg -exclude-dir = .svn www-data

www-data 31147 12770 0 ott22? 00:05:51 nginx: processo di lavoro

www-data 31148 12770 0 ott22? 00:00:00 nginx: processo di gestione cache

Puoi anche combinare più canali in una squadra. Come puoi vedere nell'output sopra, c'è anche una riga che contiene il processo. Se non si desidera visualizzare questa riga, inviare l'output a un'altra istanza, come mostrato di seguito.

$ ps -ef | www-data | grep -v grep

uscita:

www-data 18247 12675 4 16:00? 00:00:00 php-fpm: piscina www

radice 18272 17714 0 16:00 pts / 0 00:00:00 -color = auto - exclude-dir = .bzr -exclude-dir = CVS -exclude-dir = .git -exclude-dir = .hg -exclude-dir = .svn www-data

www-data 31147 12770 0 ott22? 00:05:51 nginx: processo di lavoro

www-data 31148 12770 0 ott22? 00:00:00 nginx: processo di gestione cache

Ricerca ricorsiva

Per cercare ricorsivamente un pattern, immettere l'opzione -r (o -recursive). Ciò consentirà di cercare tra tutti i file nella directory specificata, saltando i collegamenti simbolici che si verificano in modo ricorsivo. Per passare attraverso tutti i collegamenti simbolici, utilizzare l'opzione -r (o -dereferenza-ricorsiva). Nell'esempio seguente, cerchiamo domain.com in tutti i file all'interno della directory / etc:

$ -r dominio.com / ecc

Il comando stamperà i campi corrispondenti con il prefisso del percorso file completo.

/etc/hosts:127.0.0.1 node2.domain.com /etc/nginx/sites-available/domain.com: server_name domain.com www.domain.com;

Se invece di -r usi l'opzione -R, il comando seguirà tutti i link simbolici:

$ -R dominio.com / ecc

Si noti l'ultimo campo di output. Questo non è stampato nell'esempio sopra, perché i file nella directory Nginx abilitata ai siti sono collegamenti simbolici ai file di configurazione all'interno della directory dei siti disponibili.

uscita:

/etc/hosts:127.0.0.1 node2.domain.com

/etc/nginx/sites-available/domain.com: server_name domain.com www.domain.com;

/etc/nginx/sites-enabled/domain.com: server_name domain.com www.domain.com;

Mostra solo il nome del file

Per sopprimere l'output predefinito e stampare solo i nomi dei file contenenti il ​​pattern abbinato, è possibile inserire l'opzione -l (o -files-with-matches). Ad esempio, per cercare tutti i file che terminano in .conf nella directory di lavoro corrente e per stampare solo i nomi di file che contengono il tipo domain.com, digitare:

$ -L dominio.com * .conf

L'output sarà simile a questo:

tmux.conf

haproxy.conf

L'opzione -l viene solitamente utilizzata in combinazione con l'opzione -R ricorsiva:

$ -Rl dominio.com / tmp

Case insensibilità

Per impostazione predefinita, il comando è sensibile al maiuscolo / minuscolo, il che significa che i caratteri maiuscoli e minuscoli vengono trattati come diversi. Per ignorare il caso durante la ricerca, immettere l'opzione -i (o -ignore-case). Ad esempio, se si cerca una Zebra senza alcuna opzione, il seguente comando non visualizzerà alcun output, ad es. ci sono abbinamenti

$ Zebra / usr / share / words

Ma se si esegue una ricerca senza distinzione tra maiuscole e minuscole, utilizzare l'opzione -i, che corrisponderà a lettere maiuscole e minuscole:

$ grep -i Zebra / usr / share / words

L'indicazione "Zebra" corrisponderà a "Zebra", "ZEbrA" o qualsiasi altra combinazione di lettere maiuscole e minuscole.

uscita:

zebra

zebra

zebre

Corrispondenza esatta

Durante la ricerca, gnu stamperà anche gnu, in cui vengono inserite parole più grandi, come cygnus o magnum.

$ gnu / usr / share / words

uscita:

Cygnus

gnu

interregno

lgnu9d

lignum

bottiglione

Magnuson

sfagno

wingnut

Per restituire solo quelle espressioni in cui il campo specificato è una parola intera (non racchiuso tra parole), puoi usare l'opzione -w (o -word-regexp).

IMPORTANTE. I caratteri della parola includono caratteri alfanumerici (az, AZ e 0-9) e caratteri di sottolineatura (_). Tutti gli altri personaggi sono trattati come caratteri non verbali.

Se si esegue lo stesso comando di cui sopra, inclusa l'opzione -w, il comando restituirà solo quelli che includono gnu come parola separata.

$ grep -w gnu / usr / share / words

Uscita: gnu

Mostra numeri

Per mostrare il numero di linee contenenti un pattern, usa il parametro -n (o -line-number). Usando questa opzione si stamperanno le corrispondenze con lo standard output con il prefisso del numero in cui è stato trovato. Ad esempio, per visualizzare dal file / etc / services contenente il prefisso bash con il numero corrispondente, è possibile utilizzare il seguente comando:

$ grep -n 10000 / etc / services

L'output sotto mostra che le corrispondenze sono a 10423 e 10424.

uscita:

10423: ndmp 10.000 / tcp

10424: ndmp 10000 / udp

contare

Per stampare il numero di linee corrispondenti sullo standard output, utilizzare il parametro -c (o -count). Nell'esempio seguente, contiamo il numero di account che hanno la shell / usr / bin / zsh.

$ grep -c '/ usr / bin / zsh' / etc / passwd

Uscita: 4

Diverse linee (modelli)

L'operatore OR può combinare due o più pattern di ricerca |. Per impostazione predefinita, il comando interpreta il modello come espressione regolare principale, in cui i metacaratteri perdono il loro particolare significato e devono essere utilizzate le loro versioni con una barra rovesciata. Nell'esempio seguente, cerchiamo tutte le occorrenze delle parole fatal, error e critical nel file di log degli errori di Nginx:

$ grep 'fatale \ | errore \ | critico' /var/log/nginx/error.log

Se si utilizza l'opzione di espressione regolare estesa -E (o -extended-regexp), l'istruzione non deve essere sottoposta a escape, come mostrato di seguito:

$ grep -E 'fatale | errore | critico' /var/log/nginx/error.log

Espressione regolare

GNU Grep ha due serie di funzioni di espressioni regolari: base ed estesa. Per impostazione predefinita, la funzione interpreta il modello come un'espressione regolare di base, per passare a espressioni regolari estese, è necessario utilizzare l'opzione -E. Quando si usano le espressioni regolari nella modalità principale, tutti gli altri caratteri, eccetto i metacaratteri, sono in realtà espressioni regolari che corrispondono l'una all'altra. Di seguito è riportato un elenco dei metacaratteri più comunemente usati:

  • Usa il carattere ^ (il carattere di accento circonflesso) per abbinare l'espressione all'inizio di una riga. Nell'esempio seguente, ^ kangaroo corrisponderà solo se si verifica all'inizio: $ grep "^ kangaroo" file.txt
  • Usa il simbolo $ (dollaro) per abbinare l'espressione alla fine. Nell'esempio seguente, canguro $ corrisponderà solo se viene rilevato alla fine: grep "kangaroo $" file.txt
  • Usa il simbolo. (punto) per abbinare qualsiasi carattere singolo. Ad esempio, per abbinare tutto ciò che inizia con kan di due caratteri e finisce con roo, puoi usare il seguente modello: $ grep "kan..roo" file.txt
  • Usa [] (parentesi) per abbinare qualsiasi singolo carattere racchiuso tra parentesi. Ad esempio, trova quelli che contengono accept o "accent, puoi usare il seguente pattern: $ grep" acce [np] t "file.txt

Per evitare il significato speciale del prossimo carattere, usa il carattere \ (backslash).

Espressioni regolari estese

Per interpretare un modello come un'espressione regolare estesa, utilizzare il parametro -E (o -extended-regexp). Le espressioni regolari estese includono tutti i metacaratteri di base, oltre a metacaratteri aggiuntivi per la creazione di schemi di ricerca più complessi e potenti. Di seguito sono riportati alcuni esempi:

  • Abbina ed estrai tutti gli indirizzi email da questo file: $ grep -E -o "\ b [A-Za-z0-9 ._% + -] [A-Za-z0-9 .-] + \. [A-Za-z] {2.6} \ b "file.txt
  • Mappare ed estrarre tutti gli indirizzi IP validi da questo file: $ grep -E -o '(25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0 -9]?) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0- 5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0-5] | 2 [0-4] [0- 9] | [01]? [0-9] [0-9]?) 'File.txt

L'opzione -o viene utilizzata per stampare solo le corrispondenze.

Stampa prima del conteggio

Per stampare un certo numero di righe prima della corrispondenza, utilizzare il parametro -B (o -before-context). Ad esempio, per visualizzare 5 righe di contesto iniziale prima della corrispondenza, è possibile utilizzare il seguente comando: $ grep -A 5 root / etc / passwd

Stampa dopo la ricerca

Per stampare un numero specifico di righe dopo una corrispondenza, utilizzare il parametro -A (o -after-context). Ad esempio, per visualizzare 5 righe del contesto finale dopo aver confrontato le stringhe, è possibile utilizzare il seguente comando: $ grep -B 5 root / etc / passwd

Tutto ciò è necessario per il pieno utilizzo delle informazioni sui comandi. Se già usi Linux e puoi dare qualche consiglio ai principianti, condividi i commenti sotto questo articolo.