Espressioni regolari – L’ultima guida

Scarica il PDF

L’espressione regolare è un gruppo di caratteri o simboli che viene utilizzato per trovare un modello specifico da un testo; puoi chiamarli jolly su steroidi, se vuoi. Come sviluppatore, padroneggiare le espressioni regolari può essere un potente strumento da avere nella tua cintura degli strumenti; sicuramente dovrai usarle nei tuoi programmi ad un certo punto del tempo, cercare e sostituire usando le espressioni regolari negli IDE è davvero utile a volte e mi ritrovo ad usarle nella riga di comando ogni singolo giorno.

Diverse applicazioni e linguaggi di programmazione potrebbero avere diverse implementazioni per le espressioni regolari ma i concetti di base sono per lo più gli stessi. In questo post, vi spiegherò tutto quello che dovete sapere sulle espressioni regolari.

Un’espressione regolare è un modello che viene abbinato a una stringa oggetto da sinistra a destra. La parola “espressione regolare” è una parola grossa, di solito troverete il termine abbreviato come “regex” o “regexp”. L’espressione regolare è usata per sostituire un testo all’interno di una stringa, validare un modulo, estrarre una sottostringa da una stringa sulla base di un pattern match, e molto altro ancora.

Immaginate di scrivere un’applicazione e di voler impostare le regole per quando un utente sceglie il suo nome utente. Vogliamo permettere che il nome utente contenga lettere, numeri, sottolineature e trattini. Vogliamo anche limitare il numero di caratteri nel nome utente in modo che non risulti brutto. Usiamo la seguente espressione regolare per convalidare un nome utente:

La suddetta espressione regolare può accettare le stringhe john_doe, jo-hn_doe e john12_as. Non corrisponde a Jo perché questa stringa contiene lettere maiuscole ed è troppo corta.

Tabella dei contenuti

• Corrispondenti di base
• Carattere metrico
• Stop completo
• Insieme caratteri
• Insieme caratteri negativi
• Ripetizioni
• La Stella
• Il più
• Il punto interrogativo
• Braccia
• Gruppo di caratteri
• Alternazione
• Carattere speciale di fuga
• Anchors
• Caretta
• Dollaro
• Insiemi di caratteri abbreviati
• Lookaround
• Positive Lookahead
• Negative Lookahead
• Positive Lookbehind
• Flags
• Case Insensitive
• Ricerca globale
• Multilinea
• Corrispondenza avida o pigra

Corrispondenti di base

Un’espressione regolare è solo uno schema di caratteri che usiamo per eseguire
ricerche in un testo. Per esempio, l’espressione regolare the significa: la lettera
t, seguita dalla lettera h, seguita dalla lettera e.

the => The fat cat sat on the mat.

Testare l’espressione regolare

L’espressione regolare 123 corrisponde alla stringa 123. L’espressione regolare viene confrontata con una stringa di input confrontando ogni carattere dell’espressione regolare
con ogni carattere della stringa di input, uno dopo l’altro. Le espressioni regolari
sono normalmente sensibili alle maiuscole e alle minuscole, quindi l’espressione regolare The non corrisponderebbe
alla stringa the.

The => The fat cat sat on the mat.

Test dell’espressione regolare

Caratteri meta

I caratteri meta sono i mattoni delle espressioni regolari. I metacaratteri
non stanno per se stessi ma sono interpretati in qualche
modo speciale. Alcuni meta caratteri hanno un significato speciale e sono scritti all’interno di parentesi quadre. I meta caratteri sono i seguenti:

2.1 Punto fermo

Full stop . è il più semplice esempio di meta carattere. Il metacarattere .
corrisponde a qualsiasi singolo carattere. Non corrisponde ai caratteri di ritorno o di newline.
Per esempio, l’espressione regolare .ar significa: qualsiasi carattere, seguito dalla lettera a, seguito dalla lettera r.

.ar => The car parked in the garage.

Testare l’espressione regolare

2.2 Set di caratteri

I set di caratteri sono anche chiamati classe di caratteri. Le parentesi quadre sono usate per
specificare gli insiemi di caratteri. Usate un trattino all’interno di un set di caratteri per specificare la gamma di caratteri. L’ordine della gamma di caratteri all’interno delle parentesi quadre
non ha importanza. Per esempio, l’espressione regolare he significa: una maiuscola T o una minuscola t, seguita dalla lettera h, seguita dalla lettera e.

he => The car parked in the garage.

Prova l’espressione regolare

Un punto dentro un insieme di caratteri, tuttavia, significa un punto letterale. L’espressione regolare
ar significa: un carattere minuscolo a, seguito dalla lettera r,
seguito da un carattere punto ..

ar => A garage is a good place to park a car.

Testare l’espressione regolare

2.2.1 Set di caratteri negati

In generale, il simbolo del cursore rappresenta l’inizio della stringa, ma quando è
dopo la parentesi quadra di apertura, nega il set di caratteri. Per
esempio, l’espressione regolare ar significa: qualsiasi carattere tranne c,
seguito dal carattere a, seguito dalla lettera r.

ar => The car parked in the garage.

Testare l’espressione regolare

2.3 Ripetizioni

I metacaratteri seguenti +, * o ? sono usati per specificare quante volte un sottotipo può ripetersi. Questi metacaratteri agiscono diversamente in diverse
situazioni.

2.3.1 La stella

Il simbolo * corrisponde a zero o più ripetizioni del matcher precedente. L’espressione regolare a* significa: zero o più ripetizioni del carattere minuscolo precedente a. Ma se appare dopo un insieme di caratteri o una classe, allora trova le ripetizioni dell’intero insieme di caratteri. Per esempio, l’espressione regolare * significa: qualsiasi numero di lettere minuscole in una riga.

* => The car parked in the garage #21.

Prova l’espressione regolare

Il simbolo * può essere usato con il meta carattere . per trovare qualsiasi stringa di
caratteri .*. Il simbolo * può essere usato con il carattere whitespace \s
per far corrispondere una stringa di caratteri whitespace. Per esempio, l’espressione
\s*cat\s* significa: zero o più spazi, seguiti dal carattere minuscolo c,
seguito dal carattere minuscolo a, seguito dal carattere minuscolo t, seguito da zero o più spazi.

\s*cat\s* => The fat cat sat on the concatenation.

Testare l’espressione regolare

2.3.2 Il Più

Il simbolo + corrisponde a una o più ripetizioni del carattere precedente. Per esempio, l’espressione regolare c.+t significa: lettera minuscola c, seguita da almeno un carattere, seguito dal carattere minuscolo t. Bisogna chiarire che t è l’ultimo t nella frase.

c.+t => The fat cat sat on the mat.

Testare l’espressione regolare

2.3.3 Il punto interrogativo

Nell’espressione regolare il meta carattere ? rende il carattere precedente
opzionale. Questo simbolo corrisponde a zero o una istanza del carattere precedente. Per esempio, l’espressione regolare ?he significa: Opzionale la lettera maiuscola T, seguita dal carattere minuscolo h, seguito dal carattere minuscolo e.

he => The car is parked in the garage.

Testare l’espressione regolare

?he => The car is parked in the garage.

Testare l’espressione regolare

2.4 Parentesi graffe

Nelle espressioni regolari le parentesi graffe, chiamate anche quantificatori, sono usate per
specificare il numero di volte che un carattere o un gruppo di caratteri può essere
ripetuto. Per esempio, l’espressione regolare {2,3} significa: Abbinare almeno 2 cifre ma non più di 3 ( caratteri nell’intervallo da 0 a 9).

{2,3} => The number was 9.9997 but we rounded it off to 10.0.

Testare l’espressione regolare

Possiamo omettere il secondo numero. Per esempio, l’espressione regolare
{2,} significa: Abbina 2 o più cifre. Se togliamo anche la virgola l’espressione regolare
{3} significa: Corrisponde esattamente a 3 cifre.

{2,} => The number was 9.9997 but we rounded it off to 10.0.

Testare l’espressione regolare

{3} => The number was 9.9997 but we rounded it off to 10.0.

Testare l’espressione regolare

2.5 Gruppo di caratteri

Il gruppo di caratteri è un gruppo di sotto-modelli che è scritto dentro parentesi (…). Come abbiamo discusso prima, nell’espressione regolare, se mettiamo un quantificatore dopo un carattere, questo ripeterà il carattere precedente. Ma se mettiamo un quantificatore dopo un gruppo di caratteri allora ripete l’intero gruppo di caratteri. Per esempio, l’espressione regolare (ab)* corrisponde a zero o più ripetizioni del carattere ab. Possiamo anche usare l’alternanza | meta carattere all’interno del gruppo di caratteri. Per esempio, l’espressione regolare (c|g|p)ar significa: carattere minuscolo c, g o p, seguito dal carattere a, seguito dal carattere r.

(c|g|p)ar => The car is parked in the garage.

Testare l’espressione regolare

2.6 Alternanza

Nell’espressione regolare la barra verticale | è usata per definire l’alternanza. L’alternanza è come una condizione tra più espressioni. Ora, potreste pensare che il set di caratteri e l’alternanza funzionino allo stesso modo. Ma la grande differenza tra il set di caratteri e l’alternanza è che il set di caratteri lavora a livello di carattere ma l’alternanza lavora a livello di espressione. Per esempio, l’espressione regolare (T|t)he|car significa: carattere maiuscolo T o minuscolo t, seguito dal carattere minuscolo h, seguito dal carattere minuscolo e o dal carattere minuscolo c, seguito dal carattere minuscolo a, seguito dal carattere minuscolo r.

(T|t)he|car => The car is parked in the garage.

Testare l’espressione regolare

2.7 Escaping del carattere speciale

Il backlash \ è usato nell’espressione regolare per escape del carattere successivo. Questo
ci permette di specificare un simbolo come carattere corrispondente, compresi i caratteri riservati { } / \ + * . $ ^ | ?. Per usare un carattere speciale come carattere di corrispondenza, anteponi \ ad esso.

Per esempio, l’espressione regolare . è usata per corrispondere a qualsiasi carattere eccetto
newline. Ora per abbinare . in una stringa di input l’espressione regolare (f|c|m)at\.? significa: lettera minuscola f, c o m seguita dal carattere minuscolo
a, seguito dalla lettera minuscola t, seguita dal carattere opzionale ..

(f|c|m)at\.? => The fat cat sat on the mat.

Testare l’espressione regolare

2.8 Ancore

Nelle espressioni regolari, usiamo le ancore per controllare se il simbolo corrispondente è il simbolo iniziale o finale della stringa di input. Le ancore sono di due tipi: Il primo tipo è Caret ^ che controlla se il carattere corrispondente è il carattere iniziale
dell’input e il secondo tipo è Dollar $ che controlla se il carattere corrispondente
è l’ultimo carattere della stringa di input.

2.8.1 Caret

Il simbolo Caret ^viene usato per controllare se il carattere corrispondente è il primo carattere
della stringa di input. Se applichiamo la seguente espressione regolare ^a (se a è
il simbolo iniziale) alla stringa di input abc essa corrisponde a a. Ma se applichiamo l’espressione regolare ^b alla stringa di input di cui sopra, non corrisponde a nulla. Perché nella stringa di input abc b non è il simbolo iniziale. Diamo un’occhiata a un’altra espressione regolare ^(T|t)he che significa: il carattere maiuscolo T o il carattere minuscolo t è il simbolo iniziale della stringa di input, seguito da
carattere minuscolo h, seguito dal carattere minuscolo e.

(T|t)he => The car is parked in the garage.

Testare l’espressione regolare

^(T|t)he => The car is parked in the garage.

Testare l’espressione regolare

2.8.2 Dollaro

Il simbolo del dollaro $ viene usato per controllare se il carattere corrispondente è l’ultimo carattere
della stringa di input. Per esempio, l’espressione regolare (at\.)$ significa: un carattere minuscolo a, seguito da un carattere minuscolo t, seguito da un carattere . e il corrispondente deve essere la fine della stringa.

(at\.) => The fat cat. sat. on the mat.

Testare l’espressione regolare

(at\.)$ => The fat cat. sat. on the mat.

Testare l’espressione regolare

Insiemi di caratteri stenografici

L’espressione regolare fornisce stenografie per gli insiemi di caratteri comunemente usati, che offrono comode stenografie per espressioni regolari comunemente usate. Gli insiemi di caratteri stenografici sono i seguenti:

Lookaround

Lookbehind e lookahead (chiamati anche lookaround) sono tipi specifici di
gruppi non catturanti (usati per abbinare il modello ma non inclusi nella lista corrispondente). I lookahead sono usati quando abbiamo la condizione che questo pattern sia preceduto o seguito da un altro determinato pattern. Per esempio, vogliamo ottenere tutti i numeri che sono preceduti dal carattere $ dalla seguente stringa di input .44 and .88. Useremo la seguente espressione regolare (?<=$)* che significa: ottenere tutti i numeri che contengono il carattere . e sono preceduti dal carattere $. Di seguito sono riportati i lookaround utilizzati nelle espressioni regolari:

4.1 Lookahead positivo

Il lookahead positivo afferma che la prima parte dell’espressione deve essere
seguita dall’espressione lookahead. Il match restituito contiene solo il testo a cui corrisponde la prima parte dell’espressione. Per definire un
lookahead positivo, si usano delle parentesi. All’interno di queste parentesi, si usa un punto interrogativo con segno di uguale, come questo: (?=…). L’espressione Lookahead è scritta dopo il segno di uguale all’interno delle parentesi. Per esempio, l’espressione regolare
(T|t)he(?=\sfat) significa: opzionalmente corrisponde alla lettera minuscola t o alla lettera maiuscola T, seguita dalla lettera h, seguita dalla lettera e. Tra parentesi definiamo lookahead positivo che dice al motore di espressione regolare di far corrispondere The o the che sono seguiti dalla parola fat.

(T|t)he(?=\sfat) => The fat cat sat on the mat.

Testare l’espressione regolare

4.2 Lookahead negativo

Negative lookahead è usato quando abbiamo bisogno di ottenere tutte le corrispondenze dalla stringa di input
che non sono seguite da un pattern. Il lookahead negativo è definito come il lookahead positivo, ma l’unica differenza è che invece del carattere uguale = usiamo il carattere di negazione !, cioè (?!…). Diamo un’occhiata alla seguente espressione regolare (T|t)he(?!\sfat) che significa: ottieni tutte le parole The o the dalla stringa di input che non sono seguite dalla parola fat preceduta da uno spazio.

(T|t)he(?!\sfat) => The fat cat sat on the mat.

Testa l’espressione regolare

4.3 Positive Lookbehind

Positive lookbehind è usato per ottenere tutte le corrispondenze che sono precedute da un
tipo specifico. Il lookbehind positivo è indicato con (?<=…). Per esempio, l’espressione regolare (?<=(T|t)he\s)(fat|mat) significa: ottieni tutte le parole fat o mat dalla stringa di input che sono dopo la parola The o the.

(?<=(T|t)he\s)(fat|mat) => The fat cat sat on the mat.

Testa l’espressione regolare

4.4 Lookbehind negativo

Il lookbehind negativo è usato per ottenere tutte le corrispondenze che non sono precedute da un
tipo specifico. Il lookbehind negativo è indicato con (?<!…). Per esempio, l’espressione regolare (?<!(T|t)he\s)(cat) significa: ottenere tutte le catparole dalla stringa di input che non sono dopo la parola The o the.

(?<!(T|t)he\s)(cat) => The cat sat on cat.

Testare l’espressione regolare

Flags

Le flag sono anche chiamate modificatori perché modificano l’output di un’espressione regolare
. Questi flag possono essere usati in qualsiasi ordine o combinazione, e sono parte integrante della RegExp.

5.1 Case Insensitive

Il modificatore i è usato per eseguire la corrispondenza case-insensitive. Per esempio, l’espressione regolare /The/gi significa: lettera maiuscola T, seguita dal carattere minuscolo h, seguito dal carattere e. E alla fine dell’espressione regolare il flag i dice al motore di espressione regolare di ignorare il caso. Come puoi vedere abbiamo anche fornito il flag g perché vogliamo cercare il pattern nell’intera stringa di input.

The => The fat cat sat on the mat.

Testare l’espressione regolare

/The/gi => The fat cat sat on the mat.

Testare l’espressione regolare

5.2 Ricerca globale

Il modificatore g è usato per eseguire una corrispondenza globale (trovare tutte le corrispondenze piuttosto che fermarsi dopo la prima corrispondenza). Per esempio, l’espressione regolare /.(at)/g significa: qualsiasi carattere eccetto nuova linea, seguito dal carattere minuscolo a, seguito dal carattere minuscolo t. Poiché abbiamo fornito il flag g alla fine dell’espressione regolare ora troverà tutte le corrispondenze nella stringa di input, non solo la prima (che è il comportamento predefinito).

/.(at)/ => The fat cat sat on the mat.

Testare l’espressione regolare

/.(at)/g => The fat cat sat on the mat.

Testare l’espressione regolare

5.3 Multilinea

Il modificatore m è usato per eseguire una corrispondenza multilinea. Come abbiamo discusso prima
le ancore (^, $)sono usate per controllare se il pattern è l’inizio o la fine della stringa di input. Ma se vogliamo che le ancore funzionino su ogni linea, usiamo il flag
m. Per esempio, l’espressione regolare /at(.)?$/gm significa: carattere minuscolo
a, seguito dal carattere minuscolo t, opzionalmente qualsiasi cosa tranne
nuova linea. E a causa del flag m ora il motore delle espressioni regolari corrisponde al modello alla fine di ogni linea in una stringa.

/.at(.)?$/ => The fat
cat sat
on the mat.

Testa l’espressione regolare

"/.at(.)?$/gm" => The fat
cat sat
on the mat.

Testa l’espressione regolare

Corrispondenza avida o pigra

Di default la regex farà una corrispondenza avida, significa che corrisponderà finché
possibile. Possiamo usare ? per abbinare in modo pigro significa il più corto possibile

/(.*at)/ => The fat cat sat on the mat.

Testare l’espressione regolare

/(.*?at)/ => The fat cat sat on the mat.

Testare l’espressione regolare

E con questo, questo post arriva alla fine. Spero che questo post sia stato utile. Assicurati di mettere in pratica ciò che hai imparato usando servizi come regexr.com o regex101.com.

.