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.