Espressioni regolari in Grep (Regex)

grep è uno dei comandi più utili e potenti in Linux per l'elaborazione del testo. grep cerca in uno o più file di input le righe che corrispondono a un'espressione regolare e scrive ogni riga corrispondente nell'output standard.

In questo articolo, esploreremo le basi su come usare le espressioni regolari nella versione GNU di grep , disponibile per impostazione predefinita nella maggior parte dei sistemi operativi Linux.

Espressione regolare Grep #

Un'espressione regolare o regex è un modello che corrisponde a un insieme di stringhe. Un modello è costituito da operatori, costruisce caratteri letterali e metacaratteri, che hanno un significato speciale. GNU grep supporta tre sintassi di espressioni regolari, Basic, Extended e Perl-compatibile.

Nella sua forma più semplice, quando non viene fornito alcun tipo di espressione regolare, grep interpretare i modelli di ricerca come espressioni regolari di base. Per interpretare il modello come un'espressione regolare estesa, usa -E ( o --extended-regexp ) opzione.

Nell'implementazione di grep da parte di GNU non vi è alcuna differenza funzionale tra le sintassi delle espressioni regolari di base ed estese. L'unica differenza è che nelle espressioni regolari di base i metacaratteri ? , + , { , | , ( e ) sono interpretati come caratteri letterali. Per mantenere i significati speciali dei metacaratteri quando si utilizzano espressioni regolari di base, i caratteri devono essere sottoposti a escape con una barra rovesciata (\ ). Spiegheremo il significato di questi e altri meta-caratteri in seguito.

In genere, dovresti sempre racchiudere l'espressione regolare tra virgolette singole per evitare l'interpretazione e l'espansione dei metacaratteri da parte della shell.

Corrispondenze letterali #

L'utilizzo più elementare di grep il comando consiste nel cercare un carattere letterale o una serie di caratteri in un file. Ad esempio, per visualizzare tutte le righe contenenti la stringa “bash” in /etc/passwd file, eseguiresti il ​​seguente comando:

grep bash /etc/passwd

L'output dovrebbe essere simile a questo:

root:x:0:0:root:/root:/bin/bash
linuxize:x:1000:1000:linuxize:/home/linuxize:/bin/bash

In questo esempio, la stringa "bash" è un'espressione regolare di base composta da quattro caratteri letterali. Questo dice a grep per cercare una stringa che abbia una “b” immediatamente seguita da “a”, “s” e “h”.

Per impostazione predefinita, il grep il comando fa distinzione tra maiuscole e minuscole. Ciò significa che i caratteri maiuscoli e minuscoli vengono trattati come distinti.

Per ignorare maiuscole e minuscole durante la ricerca, utilizzare -i opzione (o --ignore-case ).

È importante notare che grep cerca il modello di ricerca come una stringa, non come una parola. Quindi, se stavi cercando "gnu", grep stamperà anche le righe in cui "gnu" è incorporato in parole più grandi, come "cygnus" o "magnum".

Se la stringa di ricerca include spazi, è necessario racchiuderla tra virgolette singole o doppie:

grep "Gnome Display Manager" /etc/passwd

Anchoring #

Le ancore sono metacaratteri che consentono di specificare dove deve essere trovata la corrispondenza nella riga.

Il ^ Il simbolo (caret) corrisponde alla stringa vuota all'inizio di una riga. Nell'esempio seguente, la stringa "linux" corrisponderà solo se si trova all'inizio di una riga.

grep '^linux' file.txt

Il $ Il simbolo (dollaro) corrisponde alla stringa vuota all'inizio di una riga. Per trovare una riga che termina con la stringa "linux", dovresti usare:

grep 'linux$' file.txt

Puoi anche costruire un'espressione regolare usando entrambi gli ancoraggi. Ad esempio, per trovare righe contenenti solo "linux", eseguire:

grep '^linux$' file.txt

Un altro esempio utile è il ^$ modello che corrisponde a tutte le righe vuote.

Carattere singolo corrispondente #

Il . Il simbolo (punto) è un metacarattere che corrisponde a qualsiasi singolo carattere. Ad esempio, per abbinare qualsiasi cosa che inizi con "kan" quindi abbia due caratteri e termini con la stringa "roo", dovresti utilizzare il seguente schema:

grep 'kan..roo' file.txt

Espressioni tra parentesi #

Le espressioni tra parentesi consentono di abbinare un gruppo di caratteri racchiudendoli tra parentesi [] . Ad esempio, trova le righe che contengono "accept" o "accent", puoi usare la seguente espressione:

grep 'acce[np]t' file.txt

Se il primo carattere tra parentesi è il cursore ^ , quindi corrisponde a qualsiasi singolo carattere non racchiuso tra parentesi. Il seguente schema corrisponderà a qualsiasi combinazione di stringhe che iniziano con "co" seguita da qualsiasi lettera tranne "l" seguita da "la", come "coca", "cobalt" e così via, ma non corrisponderà alle righe contenenti "cola ”:

grep 'co[^l]a' file.txt

Invece di inserire i caratteri uno per uno, puoi specificare un intervallo di caratteri all'interno delle parentesi. Un'espressione di intervallo viene costruita specificando il primo e l'ultimo carattere dell'intervallo separati da un trattino. Ad esempio, [a-a] è equivalente a [abcde] e [1-3] è equivalente a [123] .

La seguente espressione corrisponde a ogni riga che inizia con una lettera maiuscola:

grep '^[A-Z]' file.txt

grep supportano anche classi di caratteri predefinite racchiuse tra parentesi. La tabella seguente mostra alcune delle classi di caratteri più comuni:

Quantificatore	Classi di personaggi
[:alnum:]	Caratteri alfanumerici.
[:alpha:]	Caratteri alfabetici.
[:blank:]	Spazio e tabulazione.
[:digit:]	Cifre.
[:lower:]	Lettere minuscole.
[:upper:]	Lettere maiuscole.

Per un elenco completo di tutte le classi di personaggi, consulta il manuale di Grep.

Quantificatori #

I quantificatori consentono di specificare il numero di occorrenze di elementi che devono essere presenti affinché si verifichi una corrispondenza. La tabella seguente mostra i quantificatori supportati da GNU grep :

Quantificatore	Descrizione
*	Abbina l'elemento precedente zero o più volte.
?	Abbina l'elemento precedente zero o una volta.
+	Abbina l'elemento precedente una o più volte.
{n}	Abbina esattamente l'elemento precedente n volte.
{n,}	Abbina l'elemento precedente almeno n volte.
{,m}	Abbina l'elemento precedente al massimo m volte.
{n,m}	Abbina l'elemento precedente da n a m volte.

Il * Il carattere (asterisco) corrisponde all'elemento precedente zero o più volte. Quanto segue corrisponderà a "right", "sright" "ssright" e così via:

grep 's*right'

Di seguito è riportato un modello più avanzato che corrisponde a tutte le righe che iniziano con la lettera maiuscola e terminano con un punto o una virgola. Il .* regex corrisponde a qualsiasi numero di qualsiasi carattere:

grep -E '^[A-Z].*[.,]$' file.txt

Il ? Il carattere (punto interrogativo) rende facoltativo l'elemento precedente e può corrispondere una sola volta. Quanto segue corrisponderà sia a "luminoso" che a "destra". Il ? il carattere viene preceduto da una barra rovesciata perché utilizziamo espressioni regolari di base:

grep 'b\?right' file.txt

Ecco la stessa espressione regolare che utilizza un'espressione regolare estesa:

grep -E 'b?right' file.txt

Il + Il carattere (più) corrisponde all'elemento precedente una o più volte. Quanto segue corrisponderà a "sright" e "ssright", ma non a "right":

grep -E 's+right' file.txt

I caratteri di parentesi {} ti consente di specificare il numero esatto, un limite superiore o inferiore o un intervallo di occorrenze che devono verificarsi affinché si verifichi una corrispondenza.

Quanto segue corrisponde a tutti i numeri interi che hanno tra 3 e 9 cifre:

grep -E '[[:digit:]]{3,9}' file.txt

Alternanza #

Il termine alternanza è un semplice "OR". L'operatore di alternanza | (pipe) consente di specificare diverse possibili corrispondenze che possono essere stringhe letterali o set di espressioni. Questo operatore ha la precedenza più bassa di tutti gli operatori di espressioni regolari.

Nell'esempio seguente, stiamo cercando tutte le occorrenze delle parole fatal , error e critical nel file loggerror di Nginx:

grep 'fatal\|error\|critical' /var/log/nginx/error.log

Se usi l'espressione regolare estesa, allora l'operatore | non deve essere evitato, come mostrato di seguito:

grep -E 'fatal|error|critical' /var/log/nginx/error.log

Raggruppamento #

Il raggruppamento è una funzionalità delle espressioni regolari che consente di raggruppare i modelli e di farvi riferimento come un unico elemento. I gruppi vengono creati utilizzando la parentesi () .

Quando si utilizzano espressioni regolari di base, la parentesi deve essere preceduta da una barra rovesciata (\ ).

L'esempio seguente corrisponde sia a "fearless" che a "less". Il ? il quantificatore fa il (fear) gruppo facoltativo:

grep -E '(fear)?less' file.txt

Espressioni speciali di backslash #

GNU grep include diversi meta-caratteri costituiti da una barra rovesciata seguita da un carattere normale. La tabella seguente mostra alcune delle espressioni di barra rovesciata speciali più comuni:

Espressione	Descrizione
\b	Abbina un limite di parole.
\<	Trova una stringa vuota all'inizio di una parola.
\>	Trova una stringa vuota alla fine di una parola.
\w	Abbina una parola.
\s	Abbina uno spazio.

Il seguente schema corrisponderà a parole separate "abietto" e "oggetto". Non corrisponderà alle parole se incorporate in parole più grandi:

grep '\b[ao]bject\b' file.txt

Conclusione #

Le espressioni regolari vengono utilizzate negli editor di testo, nei linguaggi di programmazione e negli strumenti da riga di comando come grep , sed e awk . Sapere come costruire espressioni regolari può essere molto utile durante la ricerca di file di testo, la scrittura di script o il filtraggio dell'output dei comandi.

Se hai domande o feedback, sentiti libero di lasciare un commento.