Guida alla sintassi delle espressioni regolari (con esempi)

È da un po’ di tempo che meditavo la creazione di una guida alle espressioni regolari: in giro per la rete ce ne sono a bizzeffe, ma poche complete e pochissime in italiano; inoltre scrivere una guida dà la possibilità di ampliare le proprie conoscenze! Infatti scrivendola ho imparato cose di cui ignoravo l’esistenza!

Bisogna dire che molti preferiscono copiare ed incollare righe su righe di incomprensibili caratteri piuttosto che imparare questa strana sintassi, poiché a prima vista questa appare criptica ed incomprensibile e le espressioni sono solo lunghe serie di caratteri messi a casaccio senza un nesso logico!

Ma vedrete che non c’è nulla di difficile: basta un po’ di elasticità mentale, un pizzico di memoria e soprattutto un buon manuale da consultare spesso 😀 .

Cercherò di utilizzare una linearità nella descrizione, anche se questo mi risulterà difficile poiché è complicato spiegare un singolo elemento senza utilizzarne altri.

A che cosa servono le espressioni regolari?

Le espressioni regolari sono molto utili nell’ambito della ricerca e della sostituzione. Immaginiamo di avere un testo storico enorme e di dover convertire tutte le date in formato americano (yyyy/mm/dd) in quello classico italiano…

Sarebbe un lavoraccio doverlo fare tutto a mano! E probabilmente ci sfuggirebbero degli errori!

Ecco, con le espressioni regolari è possibile farlo in pochi caratteri! Con un risparmio di tempo, di errori e di… fegato!

La sintassi
Uguale per tutti i programmi / linguaggi?

Solitamente sì, in JavaScript e in Perl la sintassi è simile, come anche in PHP ed in altri linguaggi .
Anche Ide e programmi di testo come vim, notepad++, Komodo edit, Dreamweaver, PhpStorm, Android Studio etc. supportano il search & replace con le espressioni regolari.
Diciamo che la sintassi potrebbe cambiare, ma non di molto. E comunque se ne imparate una potrete comunque cavarvela con qualsiasi altra variante.

Gli esempi che utilizzerò qui di seguito utilizzeranno JavaScript, in modo da poterli testare al volo.

Ma passiamo alla descrizione dettagliata di ogni singolo elemento:

• come si scrive un’espressione regolare
• i metacaratteri
• i quantificatori
• i quantificatori “non golosi”
• le classi di caratteri e i POSIX
• i modificatori
• le ancore
• i caratteri speciali
• gli intervalli
• i gruppi
• le asserzioni
• conclusioni

Come si scrive un’espressione regolare

La sintassi di una espressione regolare di per sé è semplice: è sempre racchiusa da due delimitatori (in JavaScript ed in molti altri linguaggi è lo slash /, in altri è possibile anche definirlo) all’interno dei quali sono presenti le regole di ricerca e alla fine sono presenti i modificatori (come per esempio i per il case insensitive, g per ricercare tutte le occorrenze e non solo la prima, ecc.).

Ecco un esempio di espressione regolare per ricercare un URL in un testo. Non spaventatevi, alla fine della guida riuscirete a comprenderla 🙂

// Espressione regolare per ricercare un url in un testo e dividere protocollo, dominio e indirizzo
let testo = "Questa è una frase con un URL https://www.example.com/dir/subdir/demo.html nel testo";
let regex = /\b(https?):\/\/([a-z\.]+)(\/[^ $]*)*/

Ah, tutti gli esempi sono editabili ed eseguibili cliccando sul pulsante Esegui, quindi potete divertirvi e sbizzarrirvi come volete! 🙂

Gli esempi verranno eseguiti utilizzando javascript in questo modo questo modo: [testo].match([regex]), mentre se è presente la variabile replace: [testo].replace([regex], [replace])

I metacaratteri

Nelle espressioni regolari esistono diversi “caratteri speciali” dalle diverse funzioni:

let testo = 'Espressioni regolari!';
let regex = /s./;
// Trova una s seguita da qualsiasi carattere

let testo = 'Espressioni regolari!';
let regex = /^../;
// Trova i primi due caratteri

let testo = 'Espressioni regolari!';
let regex = /..$/;
// Trova gli ultimi due caratteri

let testo = 'Espressioni regolari!';
let regex = /r(a|i|u|o|e)/g;
// Trova tutte le lettere r seguite da una vocale

let testo = 'Espressioni . regolari!';
let regex = /\./;
// Trova solo il punto

I Quantificatori

I quantificatori, come dice il termine stesso, indicano quante volte ricercare una data sequenza di caratteri.

let testo = 'Espressioni, pesi, piume';
let regex = /s+i/g;
// Troverà tutte le i precedute da 1 o più s

let testo = 'Espressioni, pesi, piume';
let regex = /s*i/g;
// Troverà tutte le i precedute da 0 o più s

let testo = 'Espressioni, pesi, piume';
let regex = /s?i/g;
// Troverà tutte le i precedute da 0 o 1 s

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2}e/g;
// Troverà solamente la parola esse

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2,}e/g;
// Troverà le parole che iniziano e finiscono con e e che contengono 2 o più s

let testo = 'ese, esse, essse, esssse!';
let regex = /es{2,3}e/g;
// Troverà le parole che iniziano e finiscono con e e che contengono 2 o 3 s

I quantificatori ungreedy
(ovvero… non golosi)

Quasi tutti inciampano prima o poi in questo problema: se utilizzo una espressione del tipo /"(.*)"/ troverò tutte le parole racchiuse tra doppi apici? Purtroppo no!

Questo perché i quantificatori normali sono “golosi” (in inglese greedy), cioè cercano sempre l’occorrenza il più grande possibile.
Vediamo con un esempio:

// Voglio cercare tutte le parole racchiuse da doppi apici
var testo = '"Pluto" è un cane come "Pippo"';
var regex = /"(.*)"/g
// WTF? Non proprio il risultato sperato, vero?

WTF? Come vedete non è il risultato sperato! Come fare quindi?
Basta aggiungere un ? (punto interrogativo) subito dopo i quantificatori:

// Voglio cercare tutte le parole racchiuse da doppi apici
var testo = '"Pluto" è un cane come "Pippo"';
var regex = /"(.*?)"/g
// Magic!

Ovviamente questo vale per qualsiasi quantificatore descritto in precedenza!

È inoltre possibile specificare il modificatore U alla fine della nostra espressione regolare per indicare che tutti i quantificatori sono da considerarsi ungreedy.

Le classi e gli intervalli

Le classi determinano un elenco di caratteri, di classi di caratteri o di POSIX (vedi la sezione successiva) da ricercare. Vengono racchiusi tra parentesi quadre e possono essere seguiti dai quantificatori.

var testo = 'Questa è una stringa lunga lunga di esempio';
var regex = /[aiuoe]{2}/g
// Troverà due vocali consecutive nella stringa

Per identificare un intervallo invece si utilizza il segno - (trattino alto). Per esempio a-z identificherà tutti i caratteri minuscoli dalla a alla z, F-R i caratteri maiuscoli dalla F alla R, 0-5 i numeri da 0 a 5 e così via.

var testo = 'Un codice aa12bb ed un colore esadecimale 94fa3c';
var regex = /[0-9a-f]{6}/g
// Troverà 6 caratteri che siano numeri o lettere dalla a alla f

Il carattere ^ posto subito dopo la parentesi quadra aperta nega tutto l’intervallo, cioè indica di non ricercare i caratteri inclusi.

var testo = 'Questa è una stringa lunga lunga di esempio';
var regex = /[^aiuoe ]{3}/g
// Troverà 3 caratteri minuscoli che non siano vocali o spazi

Le classi di caratteri e i POSIX

Le classi di caratteri e i POSIX servono per specificare una serie di caratteri allo stesso tempo, senza dover scomodare gli intervalli.
Da ricordarsi che i POSIX in JavaScript non sono implementati, mentre in PHP devono essere racchiusi da una doppia parentesi quadra.

var testo = '[[Le_Regex sono_belle!!!]]';
var regex = /\w+/g;
// Troverà solo i caratteri word

var testo = '[[Le_Regex sono_belle!!!]]';
var regex = /\W+/g;
// Troverà solo i caratteri non word

var testo = '123 stella! 456 cometa!';
var regex = /\d+/g;
// Troverà solo i numeri

var testo = '123 stella! 456 cometa!';
var regex = /\D+/g;
// Troverà tutto quello che non è numero...
// Anche gli spazi!

var testo = `Manuale	sulle 
	espressioni   regolari!`;
var regex = /\s+/g;
var replace = '*';
// Sostituirà tutti gli spazi con *

var testo = "Questa è una !frase_lunga!";
var regex = /\S+/g;
// Troverà tutte le parole separate da spazi

I modificatori

Ogni operazione di ricerca può utilizzare vari modificatori, che, come dice il nome stesso, possono modificare i criteri di ricerca predefiniti.
Questi modificatori devono essere posizionati alla fine della stringa di ricerca, subito dopo il carattere di limitazione.
È possibile combinare più effetti accodando senza spazi i modificatori (per esempio: /im applicherà tutti e due gli effetti sotto descritti).

var testo = 'E uno, due tre e quattro! ';
var regex = /[a-zA-Z]{3,}/g;
// Troverà tutte le parole di almeno 3 lettere

var testo = 'Le Espressioni Regolari sono regolari?';
var regex = /regolari/gi;
// Troverà sia Regolari che regolari

var testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
var regex = /una$/gm;
// Troverà sole le "una" a fine riga

var testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
var regex = /una./gs;
// Troverà tutte le "una" seguite da un carattere

var testo = 'Espressioni regolari, 正则表达式, रेग्युलर ऍक्सप्रैशन';
var regex = /\p{sc=Han}/gu;

Le ancore

Le ancore identificano la posizione in cui ricercare il testo.

var testo = `Questo è un testo
su più righe`;
var regex = /^\w+/g;
// Troverà la prima parola

var testo = `Questo è un testo
su più righe`;
var regex = /\w+$/gm;
// Troverà l'ultima parola di ogni riga 

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\bsi/g;
// troverà solo le parole che iniziano per "si"

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /si\b/g;
// troverà solo le parole che finiscono per "si"

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\bsi\b/g;
// troverà solo i "si" non all'interno di altre parole

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\Bsi/g;
// troverà solo i "si" preceduti da una lettera

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /si\B/g;
// troverà solo i "si" seguiti da una lettera

var testo = 'si, è simpatico e positivo in certi casi';
var regex = /\Bsi\B/g;
// troverà solo i "si" all'interno di una parola

I caratteri speciali

Chi ha un po’ di conoscenza di programmazione avrà già avuto a che fare con quei segnaposto che identificano dei caratteri speciali, come quelli di fine riga o le tabulazioni. Tali segnaposto iniziano tutti con il carattere \ (barra)
Ecco un elenco molto più che dettagliato, da sottolineare l’importanza di \Q e \E, purtroppo non implementati in javaScript.

I gruppi

I gruppi vengono racchiusi dalle parentesi tonde e diventano essenziali nel momento della sostituzione, poiché è possibile richiamarli. Un esempio per chiarire tutto:

var testo = 'Questo è una data: 2010-01-28'; // data in formato anno-mese-giorno
var regex = /(\d{4})-(\d{2})-(\d{2})/g;
var replace = '$3/$2/$1'
// Ora il testo avrà la data in formato giorno/mese/anno

Come vedete l’espressione contiene tre gruppi e nella sostituzione compaiono dei dollari seguiti da un numero: questo numero rappresenta il testo trovato dal gruppo corrispondente. Così $1 identificherà il primo gruppo, $2 il secondo e così via.

In alcuni linguaggi è possibile utilizzare \1 e \2 invece che $1 e $2, ma ve lo sconsiglio in quanto le barre dentro una stringa devono essere precedute da un’altra barra e questo rende tutto meno leggibile.

Molto utile invece è la possibilità di dare dei nomi ai gruppi, così da evitare fraintendimenti con i numeri od errori in caso di spostamenti o creazioni di nuovi gruppi. Per fare questo basta aggiungere ?<nome> subito dopo l’apertura della parentesi e richiamarli con $<nome>:

var testo = 'Questo è una data: 2010-01-28'; // data in formato anno-mese-giorno
var regex = /(?<anno>\d{4})-(?<mese>\d{2})-(?<giorno>\d{2})/g;
var replace = '$<giorno>/$<mese>/$<anno>'
// Ora il testo avrà la data in formato giorno/mese/anno

Nei gruppi inoltre è possibile aggiungere un’espressione logica “OR”, cioè poter ricercare una serie di caratteri oppure un’altra:

var testo = 'In italiano si può dire sia aveva piovuto o era piovuto!'; 
var regex = /\b((aveva|era) piovuto)\b/g;
// L'espressione cercherà "ha piovuto" oppure "è piovuto"

Questa funzione ritornerà sia aveva piovuto che era piovuto; ma fate attenzione, poiché anche in questo caso le parentesi tonde rappresentano un gruppo e quindi verrà considerato nelle variabili di sostituzione, in questo caso $1 conterrà aveva piovuto, $2 conterrà aveva, $3 era piovuto e in $4 era.
Qui non sembra un problema, ma nelle espressioni più complesse ricercare cose non necessarie complica orrendamente le cose. Come fare allora? Basta utilizzare i gruppi passivi, aggiungendo un ?: subito dopo la parentesi tonda aperta:

var testo = 'In italiano si può dire sia aveva piovuto o era piovuto!'; 
var regex = /\b((?:aveva|era) piovuto)\b/g;
// L'espressione cercherà "ha piovuto" oppure "è piovuto" senza raggruppare "aveva" e "era"

Se analizzate il risultato ora conterrà solamente “aveva piovuto” e “era piovuto”.

Le asserzioni

Ho lasciato appositamente per ultime le asserzioni, visto che la maggior parte delle persone ha molta difficoltà ad assimilarle. Però una volta imparate le userete spesso e volentieri!

Esponiamo un problema: è possibile ricercare solo quelle parole che iniziano con la lettera “c” ma che la seconda lettera non sia una vocale? Certo, basta utilizzare le asserzioni!

In pratica sono degli elementi di controllo che vengono applicati alle nostre ricerche.
Inoltre tutte le asserzioni sono passive, cioè, come spiegato prima nei gruppi, non vengono aggiunte fra le variabili di ricerca.

È un po’ complicato da spiegare, ma vedrete che con gli esempi qui sotto tutto risulterà più chiaro!

var testo = "cane crotalo canarino criceto cervo";
var regex = /\b(c(?=[aiuoe])\w+)/g;
// L'espressione cercherà le parole che iniziano con la c 
// solo se sono seguite da una vocale

var testo = "cane crotalo canarino criceto cervo";
var regex = /\b(c(?![aiuoe])\w+)/g;
// L'espressione cercherà le parole che iniziano con la c 
// solo se non sono seguite da una vocale

var testo = "cesto pasto fasto pesto costo";
var regex = /(\w+(?<=a)sto)/g;
// L'espressione cercherà le parole che finiscono con sto
// solo se la lettera precendente è una a

var testo = "cesto pasto fasto pesto costo";
var regex = /(\w+(?<!a)sto)/g;
// L'espressione cercherà le parole che finiscono con sto
// solo se la lettera precendente non è una a

In questi esempi ho fatto delle asserzioni solamente su dei caratteri, ma è possibile utilizzarle anche su interi gruppi!

Conclusioni

Bene, ora avete una infarinatura sulle espressioni regolari!
Per creare e testare la vostra regex potete utilizzare il servizio offerto da regex101.com, il quale vi mostra il risultato della vostra espressione al volo con pure la descrizione 🙂 (esempio)

In futuro aggiornerò questa guida aggiungendo esempi e nuove descrizioni, quindi vi consiglio di aggiungerla ai preferiti!
Ovviamente se avete cose da aggiungere potete farlo nei commenti!

^{Ultimo aggiornamento: 02/05/2021}