Le espressioni regolari

Guida alla sintassi con esempi interattivi

È 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 e incollare righe su righe d'incomprensibili caratteri piuttosto che imparare questa strana sintassi, poiché a prima vista questa appare criptica e 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 e 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

La sintassi di una espressione regolare di per sé è semplice: è sempre racchiusa da due delimitatori (in JavaScript e 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.).

        ╔═══╗╔═══════════╗╔═══╗╔═══╗                
        ║ / ║║ [a-f0-9]+ ║║ / ║║ m ║                
        ╚═╤═╝╚═════╤═════╝╚═╤═╝╚═╤═╝┌──────────────┐
┌─────────┴────┐   │        │    └──┤ modificatore │
│ delimitatore │   │        │       └──────────────┘
│   iniziale   │   │        │ ┌──────────────┐      
└──────────────┘   │        └─┤ delimitatore │      
             ┌─────┴───────┐  │    finale    │      
             │ espressione │  └──────────────┘      
             │   regolare  │                        
             └─────────────┘                        
                                                    

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

// Trova tutti i link in un testo
const testo = `questo è un link: http://www.example.com/test
    un altro link: https://example2.com/con-url/lungo.html
    vai su "https://www.chalda.it" e non te ne pentirai!`;
const regex = /\b(https?):\/\/([\w\.]+)(\/[^\s"']*)?/g;
const match = testo.match(regex);
console.log(match);

Ah, tutti gli esempi sono presentati in javaScript, e sono eseguibili cliccando sul pulsante ▶, ed è possibile modificare il testo, l'espressione regolare e i modificatori, quindi potete divertirvi e sbizzarrirvi come volete! 🙂

Le funzioni utilizzate sono match per la ricerca e replace per la sostituzione

I metacaratteri

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

. Il punto (qualsiasi carattere)

Il punto significa qualsiasi carattere a eccezione di quelli che identificano una riga nuova (\n e \r per intenderci)

// Trova una s seguita da 3 caratteri
const testo = `Espressioni regolari!`;
const regex = /s.../g;
const match = testo.match(regex);
console.log(match);

^ L'accento circonflesso (inizio riga)

L'accento circonflesso identifica l'inizio di una riga; inoltre all'inizio di un gruppo nega il gruppo stesso (vedi i gruppi)

// Trova i primi due caratteri
const testo = `Espressioni regolari!`;
const regex = /^../;
const match = testo.match(regex);
console.log(match);

$ Il dollaro (fine riga)

Il dollaro identifica la fine di una riga

// Trova gli ultimi due caratteri
const testo = `Espressioni regolari!`;
const regex = /..$/;
const match = testo.match(regex);
console.log(match);

( ) Le parentesi tonde (gruppi)

Le parentesi tonde identificano i gruppi di caratteri

// Trova ss o sp
const testo = `Espressioni regolari!`;
const regex = /(ss|sp)/g;
const match = testo.match(regex);
console.log(match);

| Il pipe (or)

Il pipe è una condizione OR da inserire ne i gruppi

// Trova tutte le lettere r seguite da una vocale
const testo = `Espressioni regolari!`;
const regex = /r(a|i|u|o|e)/g;
const match = testo.match(regex);
console.log(match);

[ ] Le parentesi quadrate (intervalli e classi)

Le parentesi quadrate identificano le classi e gli intervalli di caratteri

\ La barra (escape)

La barra (backslash) annulla gli effetti del metacarattere successivo

// Trova solo il punto e non qualsiasi carattere
const testo = ` Espressioni . regolari!`;
const regex = /\./g;
const match = testo.match(regex);
console.log(match);

I quantificatori

I quantificatori, come dice il termine stesso, indicano quante volte ricercare una data sequenza di caratteri. Si posizionano dopo l'elemento da ricercare

+ Il più (>=1)

Indica 1 o più occorrenze

// Trova una o più s seguite da i
const testo = `Espressioni, pesi, piume`;
const regex = /s+i/g;
const match = testo.match(regex);
console.log(match);

* L'asterisco (>=0)

Indica 0 o più occorrenze. È simile al + ma l'elemento da ricercare potrebbe anche non essere presente

// Trova tutte le i precedute o no da una o più lettere s
const testo = `Espressioni, pesi, piume`;
const regex = /s*i/g;
const match = testo.match(regex);
console.log(match);

? Il punto di domanda (1 o 0)

Indica 1 o 0 occorrenze, in pratica specifica che l'elemento potrebbe o non potrebbe essere presente

// Trova tutte le i precedute da una o da nessuna s
const testo = `Espressioni, pesi, piume`;
const regex = /s?i/g;
const match = testo.match(regex);
console.log(match);

{n} Numero racchiuso da parentesi graffe (n)

Ricercano esattamente n occorrenze, dove n è un numero intero; Da ricordare che le parentesi graffe vengono considerate caratteri normali in tutti gli altri contesti

// Trova solamente la parola esse
const testo = `ese, esse, essse, esssse!`;
const regex = /es{2}e/g;
const match = testo.match(regex);
console.log(match);

// Cerca solamente la A racchiusa da parentesi graffe
const testo = `parola {a} parola`;
const regex = /{a}/;
const match = testo.match(regex);
console.log(match);

{n,m} Numeri separati da virgola racchiusi da parentesi graffe (da n a m)

Ricerca tra le n e le m occorrenze compresi, vedi sopra

// Trova solamente le parole che contengono da 2 a 4 s
const testo = `ese, esse, essse, esssse, essssse!`;
const regex = /es{2,4}e/g;
const match = testo.match(regex);
console.log(match);

{n,} Numero seguito da una virgola racchiuso da parentesi graffe (da n)

Ricerca un minimo di n occorrenze, vedi sopra

// Trova solamente le parole che contengono 2 o più s
const testo = `ese, esse, essse, esssse, essssse!`;
const regex = /es{2,}e/g;
const match = testo.match(regex);
console.log(match);

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 non sempre!

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
const testo = `"Pluto" è un cane come "Pippo"`;
const regex = /"(.*)"/g;
const match = testo.match(regex);
console.log(match);

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
const testo = `"Pluto" è un cane come "Pippo"`;
const regex = /"(.*?)"/g;
const match = testo.match(regex);
console.log(match);

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, ma purtroppo non è implementato in javaScript!

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.

// Cerco due vocali consecutive nella stringa
const testo = `Questa è una stringa lunga lunga di esempio`;
const regex = /[aiuoe]{2}/g;
const match = testo.match(regex);
console.log(match);

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.

// Cerco 6 caratteri che siano numeri o lettere dalla a alla f
const testo = `Un codice aa12bb ed un colore esadecimale 94fa3c`;
const regex = /[0-9a-f]{6}/g;
const match = testo.match(regex);
console.log(match);

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

// Troverà 3 caratteri minuscoli che non siano vocali
const testo = `Questa è una stringa lunga lunga di esempio`;
const regex = /[^aiuoe]{3}/g;
const match = testo.match(regex);
console.log(match);

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.

Solitamente una classe maiuscola è la negazione di quella minuscola.

\w Parole

Ricerca un carattere “parola” (w sta per word), cioè lettere, numeri e _ ( underscore), corrisponde a [a-zA-Z0-9_]. Si può utilizzare anche il POSIX [:word:]

// Troverà solo i caratteri word
const testo = `[[Le_Regex sono_belle!!!]]`;
const regex = /\w+/g;
const match = testo.match(regex);
console.log(match);

\W Non parole

L'opposto di \w, cioè qualsiasi cosa che non sia una lettera, numero o “_”, corrisponde a [^a-zA-Z0-9_]

// Troverà solo i caratteri word
const testo = `[[Le_Regex sono_belle!!!]]`;
const regex = /\W+/g;
const match = testo.match(regex);
console.log(match);

\d Numeri

Ricerca un numero (d sta per digit), corrisponde a [0-9]. Si può utilizzare anche il POSIX [:digit:]

// Troverà solo numeri
const testo = `123 stella! 456 cometa!`;
const regex = /\d+/g;
const match = testo.match(regex);
console.log(match);

\D Non numeri

L'opposto di \d, cioè qualsiasi cosa che non sia un numero, corrisponde a [^0-9]

// Troverà tutto quello che non è un numero
const testo = `123 stella! 456 cometa!`;
const regex = /\D+/g;
const match = testo.match(regex);
console.log(match);

\s Spazi

Ricerca uno spazio, comprese tabulazioni e caratteri di fine riga, corrisponde a [ \t\r\n\v\f]. Si può utilizzare anche il POSIX [:space:]

// Troverà solo gli spazi
const testo = `Manuale!
  sulle espressioni   regolari!`;
const regex = /\s+/g;
const match = testo.match(regex);
console.log(match);

\S Non spazi

L’inverso di \s, ricerca qualsiasi cosa non sia uno spazio, una tabulazione o dei caratteri di fine riga, corrisponde a [^ \t\r\n\v\f]

// Troverà tutto ciò che è racchiuso da spazi
const testo = `Manuale!
  sulle espressioni   regolari!`;;
const regex = /\S+/g;
const match = testo.match(regex);
console.log(match);

\p{X} Carattere unicode

Ricerca un carattere unicode di tipo X. Da utilizzare congiuntamente al modificatore u Alcuni dei tipi utilizzabili sono:

\p{L}

Qualsiasi tipo di carattere in qualsiasi linguaggio, estendibile in:

• \p{Ll} : minuscolo che ha una variante maiuscola
• \p{Lu} : maiuscolo che ha una variante minuscola
• \p{Lt} : d'inizio parola con solo l'iniziale maiuscola
• \p{L&} : che ha sia una variante minuscola che maiuscola (Ll+Lu+Lt)
• \p{Lm} : carattere speciale usato come lettera
• \p{Lo} : che non ha il corrispettivo maiuscolo o minuscolo

// Troverà tutte le parole in ogni lingua, anche con lettere accentate!
const testo = `Èspressioni regòlari, 正規表現, Regulärer Ausdruck, تعبير نمطي`;
const regex = /\p{L}+/gu;
const match = testo.match(regex);
console.log(match);

\p{M}

Carattere come accenti, umlaut, ecc. Estendibile in:

• \p{Mn} : che si combina a un altro senza occupare uno spazio
• \p{Mc} : che si combina a un altro e che occupa uno spazio
• \p{Me} : che racchiude il carattere a cui si combina (cerchio, quadrato, ecc)

\p{Z}

Qualsiasi tipo di spazio o separatore invisibile

• \p{Zs} : che occupa uno spazio
• \p{Zl} : separatore di linea (U+2028)
• \p{Zp} : separatore di paragrafo (U+2029)

// Troverà tutti gli spazi
const testo = `Le Espressioni regolari`;
const regex = /\p{Z}+/gu;
const match = testo.match(regex);
console.log(match);

\p{S}

Simboli matematici, valute, decorativi

• \p{Sm} : qualsiasi simbolo matematico
• \p{Sc} : qualsiasi simbolo di valuta
• \p{Sk} : un carattere che si combina a un altro
• \p{So} : altri simboli che non sono matematici, di valuta o di combinazione

// Troverà solo i simboli matematici
const testo = `Il nove: 3 + 3 + 3 = 3² = √81 = Ⅸ`;
const regex = /\p{Sm}+/gu;
const match = testo.match(regex);
console.log(match);

\p{N}

Caratteri numerici

• \p{Nd} : dallo 0 al 9 in qualsiasi scrittura non ideogramma
• \p{Nl} : che sembrano una lettera, come i numeri romani
• \p{No} : cifra in apice o pedice, o che non è una cifra 0-9, non ideogramma

// Troverà tutti i numeri
const testo = `Il nove: 3 + 3 + 3 = 3² = √81 = Ⅸ`;
const regex = /\p{N}+/gu;
const match = testo.match(regex);
console.log(match);

\p{P}

Caratteri di punteggiatura

• \p{Pd} : qualsiasi tipo di trattino o linea
• \p{Ps} : qualsiasi tipo di parentesi aperta
• \p{Pe} : qualsiasi tipo di parentesi chiusa
• \p{Pi} : qualsiasi tipo di virgoletta d'inizio
• \p{Pf} : qualsiasi tipo di virgoletta di fine
• \p{Pc} : che connette più parole, tipo l'underscore
• \p{Po} : qualsiasi altro carattere

// Troverà le parentesi aperte e chiuse
const testo = `⧼ {[(5+1)+7]*(2+x)}=(a+b)*4 ⧽`;
const regex = /[\p{Ps}\p{Pe}]+/gu;
const match = testo.match(regex);
console.log(match);

\p{C}

Caratteri di controllo invisibili e altri caratteri

• \p{Cc} : un carattere di controllo ASCII o Latin-1: 0x00–0x1F e 0x7F–0x9F
• \p{Cf} : indicatore di formattazione invisible
• \p{Co} : carattere riservato per uso privato
• \p{Cs} : metà di una coppia surrogata nella codifica UTF-16
• \p{Cn} : qualsiasi codice a cui non è stato assegnato un carattere

\p{sc=xxx}

Caratteri solo nella lingua xxx specificata, dove xxx è il codice che definisce la lingua ISO15924. Ecco alcuni esempi:

• \p{sc=Latin} : un carattere latino
• \p{sc=Han} : un carattere cinese
• \p{sc=Greek} : un carattere greco
• \p{sc=Cyrillic} : un carattere cirillico

\p{XXX}

Altri codici, ne elencherò solo alcuni di utili

• \p{Emoji_Presentation} : Cerca tutti gli emoji
• \p{Emoji_Modifier} : Cerca solo i caratteri che modificano l'emoji
• \p{ASCII} : Solo caratteri ascii

Potete trovare tutte le tipologie di codice a questo indirizzo , ma il supporto varia a seconda del linguaggio utilizzato

I seguenti POSTFIX non sono implementati in javaScript, quindi non sono presenti esempi:

[:alnum:]

Ricerca caratteri alfanumerici, senza _. Corrisponde a [a-zA-Z0-9]

[:alpha:]

Ricerca caratteri alfabetici. Corrisponde a [a-zA-Z]

[:blank:]

Ricerca solo spazi e tabulazioni. Corrisponde a [ \t]

[:lower:]

Ricerca solo lettere minuscole. Corrisponde a [a-z]

[:upper:]

Ricerca solo lettere maiuscole. Corrisponde a [A-Z]

[:graph:]

Ricerca tutti i caratteri visibili a video della tabella ASCII non estesa, dal numero 33 (!) al 126 (~). Corrisponde a [\x21-x7E]

[:print:]

Ricerca tutti i caratteri visibili a video della tabella ASCII non estesa, dal numero 32 (spazio) al 126 (~). Corrisponde a [\x20-x7E]

[:punct:]

Ricerca tutti i caratteri di punteggiatura. Corrisponde a [\-!”#\$%&’\(\)*+,\.\\/:;<=>\?@\[\]\^_{\|}~]

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).

g Global

In JavaScript indica una ricerca “globale”, cioè non si ferma solo alla prima corrispondenza

// Troverà tutte le parole di almeno 3 lettere
const testo = `E uno, due tre e quattro!`;
const regex = /[a-zA-Z]{3,}/g;
const match = testo.match(regex);
console.log(match);

i case-Insensitive

La ricerca diventa case-insensitive, cioè maiuscole e minuscole vengono considerate uguali

// Troverà la parola "regolari" in qualsiasi forma maiuscola/minuscola
const testo = `Le Espressioni Regolari sono regolari o ReGoLaRi?`;
const regex = /regolari/gi;
const match = testo.match(regex);
console.log(match);

m Multiline

La ricerca verrà considerata “per riga”, cioè le ancore tipo ^ e $ verranno applicate per ogni riga di testo

// Troverà sole le *una* a fine riga
const testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
const regex = /una$/gm;
const match = testo.match(regex);
console.log(match);

s Space

Il testo viene considerato un’unica riga e . ora identifica anche i caratteri di fine riga, che normalmente non troverebbe

// Troverà sole le *una* a fine riga
const testo = `Questa è una
frase su più righe e una sentenza
con molta fortuna`;
const regex = /una./gs;
const match = testo.match(regex);
console.log(match);

u Unicode

Vengono abilitati i caratteri Unicode estesi. Vedi la classe \p{X}

// Troverà solo il testo in cinese
const testo = `Espressioni regolari, 正则表达式, रेग्युलर ऍक्सप्रैशन`;
const regex = /\p{sc=Han}+/gu;
const match = testo.match(regex);
console.log(match);

U Ungeedy

Attiva l’opzione ungreedy a tutti i quantificatori, non applicabile in JavaScript

Le ancore

Le ancore identificano la posizione in cui ricercare il testo.

^ Inizio stringa

Identifica l’inizio della stringa; con il modificatore /m identifica l’inizio di ogni riga

// Troverà la prima parola
const testo = `Questo è un testo
su più righe`;
const regex = /^\w+/g;
const match = testo.match(regex);
console.log(match);

$ Fine stringa

Identifica la fine della stringa; con il modificatore /m identifica la fine di ogni riga

// Troverà sl'ultima parola
const testo = `Questo è un testo
su più righe`;
const regex = /\w+$/g;
const match = testo.match(regex);
console.log(match);

\A Inizio stringa reale

Similmente a ^, identifica solo l’inizio della stringa, anche se è presente il modificatore /m. Non è presente in JavaScript

\Z Fine stringa reale

Similmente a $, identifica solo la fine della stringa, anche se è presente il modificatore /m. Non è presente in JavaScript

\b Carattere di delimitazione parola

Identifica quel punto tra un carattere \w ([a-zA-Z0-9_]) e uno che non lo è. Il punto non ha lunghezza e può identificare anche l’inizio o la fine della stringa. \ Per esempio troverà il punto tra una lettera e un simbolo ma non il punto tra una lettera e un’altra lettera. \ È un concetto un po’ complicato, per questo è meglio chiarirlo con tre esempi

// Troverà solo le parole che iniziano per "si"
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /\bsi/g;
const match = testo.match(regex);
console.log(match);

// Troverà solo le parole che finiscono per "si"
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /si\b/g;
const match = testo.match(regex);
console.log(match);

// Troverà solo i "si" non all'interno di altre parole
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /\bsi\b/g;
const match = testo.match(regex);
console.log(match);

\B Carattere di delimitazione parola... inverso

L’opposto di \b, in pratica identifica quel punto tra due caratteri \w oppure tra due caratteri non \w. Per esempio troverà il punto tra due lettere oppure il punto tra due simboli.

// Troverà solo i "si" preceduti da una lettera
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /\Bsi/g;
const match = testo.match(regex);
console.log(match);

// Troverà solo i "si" seguiti da una lettera
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /si\B/g;
const match = testo.match(regex);
console.log(match);

// Troverà solo i "si" all'interno di una parola
const testo = `«si si! è "simpatico" e positivo in certi casi!»`;
const regex = /\Bsi\B/g;
const match = testo.match(regex);
console.log(match);

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.

• \t: Carattere di tabulazione (HT, TAB), il tasto ↹ sulla tastiera
• \n: Carattere di fine riga (LF, LN)
• \r: Carattere di ritorno a capo (CR)
• \Q: disabilita qualsiasi metacarattere presente fino a \E, molto utile per inserire delle variabili nella stringa. Non implementato in javascript
• \E: Vedi sopra. Non implementato in javascript
• \nnn: Carattere in forma ottale dove n è un numero da 0 a 7
• \xnn: Carattere in forma esadecimale dove n è un numero esadecimale a-z0-9
• \f: Carattere di Form feed (FF)
• \a: Carattere di alarm/bell (BEL)
• \e: Carattere di escape (ESC)

I gruppi

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

// Converte le date da anno-mese anno a giorno/mese/anno
const testo = `Questa è una data: 2010-01-28
e questa è un'altra data: 2022-10-22`;
const regex = /(\d{4})-(\d{2})-(\d{2})/g;
const replace = '$3/$2/$1';
console.log(testo.replace(regex, replace));

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. Tutta la stringa trovata verrà inserita in $0.

È possibile anche richiamare un gruppo nell'espressione regolare utilizzando \1 e \2, utile nelle ricerche di elementi racchiusi dallo stesso elemento:

// Cerca un testo racchiuso da apici ' o ", ma non da apici diversi
const testo = `->"questa la trova"
-> 'questa anche' <-
'questa no!"
"e questa neache'`;
const regex = /(['"]).*?\1/g;
const match = testo.match(regex);
console.log(match);

Molto utile è la possibilità di dare dei nomi ai gruppi, così da evitare fraintendimenti con i numeri o 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>:

// Converte le date da anno-mese anno a giorno/mese/anno
const testo = `Questa è una data: 2010-01-28 
e questa è un'altra data: 2022-10-22`;
const regex = /(?<anno>\d{4})-(?<mese>\d{2})-(?<giorno>\d{2})/g;
const replace = ' <giorno>/<mese>/<anno>';
console.log(testo.replace(regex, replace));

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

// L'espressione cercherà "ha piovuto" oppure "è piovuto"
const testo = `In italiano si può dire sia aveva piovuto o era piovuto!`;
const regex = /\b((aveva|era) piovuto)\b/g;
const replace = ' $2 nevicato';
console.log(testo.replace(regex, replace));

Questa funzione ritornerà sia aveva piovuto che era piovuto; ma attenzione! Come notate, 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 o 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:

// L'espressione cercherà "ha piovuto" oppure "è piovuto"
// senza recuperare il gruppo "aveva piovuto" e "era piovuto"
// Ora il gruppo $1 conterrà aveva/era
const testo = `In italiano si può dire sia aveva piovuto o era piovuto!`;
const regex = /\b(?:(aveva|era) piovuto)\b/g;
const replace = ' $1 nevicato';
console.log(testo.replace(regex, replace));

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! (ne ho messi addirittura due per tipo 😝)

(?=cond) Asserzione lookahead positiva

Asserzione lookahead positiva, cioè valida l’espressione precedente solo se la condizione cond è verificata.

// Cercherà le parole precedenti a quelle che iniziano per c, u, e
const testo = `La volpe conosce molti trucchi e l'istrice uno solo, ma buono.`;
const regex = /\w+(?= [cue])/g;
const match = testo.match(regex);
console.log(match);

Come notate le parole trovate sono solo quelle seguite da una parola che inizia per c, u ,e, ma nei gruppi trovati questa lettera non è presente! Un altro esempio utile per capirne il funzionamento è ricercare solo le parole che precedono uno spazio e capr e la parola subito successiva:

// Cercherà la parola precedente " capr" e la parola successiva
const testo = `il cane, il caprone, la mucca, il crotalo, delle piccole caprette`;
const regex = /\w+(?= capr) \w+/g;
const match = testo.match(regex);
console.log(match);

(?=cond) Asserzione lookahead negativa

Asserzione lookahead negativa, cioè valida l’espressione precedente solo se la condizione cond non è verificata.

// L'espressione cercherà la parola due seguita da qualsiasi parola
// diversa da pesi
const testo = `due pesi, due misure o due pesi e due misurazioni?`;
const regex = /due (?!pesi)\w+/g;
const match = testo.match(regex);
console.log(match);

Ricordatevi sempre che il gruppo delle asserzioni non verrà mai restituito!

// Cercherà la parola non precedente a " capr" e la parola successiva
const testo = `il cane, il caprone, la mucca, il crotalo, le caprette, il rinoceronte`;
const regex = /\w+(?! capr) \w+/g;
const match = testo.match(regex);
console.log(match);

(?<=cond) Asserzione lookbehind positiva

Asserzione lookbehind positiva, cioè valida l’espressione successiva solo se la condizione cond è verificata.

// L'espressione cercherà la parola successiva a "due "
const testo = `due pesi, due misure o due pesi e ventidue misurazioni?`;
const regex = /(?<=due )\w+/g;
const match = testo.match(regex);
console.log(match);

Se per esempio voglio trovare solo le parole con gli articoli il, lo e la mi basterà utilizzare la seguente espressione:

// L'espressione cercherà le parole con gli articoli il, lo e la
const testo = `il cane, lo scoiattolo, la mucca, gli emù nello stagno`;
const regex = /(?<=\b(?:il|lo|la) )\w+/g;
const match = testo.match(regex);
console.log(match);

Come vedete la ricerca non troverà stagno perché è presente l'ancora \b. Provate a modificarla togliendolo e vedrete la differenza! Ah, provate pure a togliere il gruppo passivo ?:

Analizziamola meglio nel dettaglio:

         ╔═══╗╔══╗╔═════════════╗╔═╗╔═══╗  
         ║(?=║║\b║║(?:il|lo|la) ║║)║║\w+║  
         ╚╤══╝╚╤═╝╚═╤═══════════╝╚╤╝╚═╤═╝  
┌─────────┴──┐ │ ┌──┴──────┐   ┌──┘   │    
│ Inizio     │ │ │ Gruppo  │   │ ┌────┴───┐
│ Asserzione │ │ │ Passivo │   │ │ Parola │
└────────────┘ │ └─────────┘   │ └────────┘
     ┌─────────┴────┐    ┌─────┴──────┐    
     │ Delimitazione│    │ Fine       │    
     │ parola       │    │ Asserzione │    
     └──────────────┘    └────────────┘    
                                           

(?<!cond) Asserzione lookbehind negativa

Asserzione lookbehind negativa, cioè valida l’espressione successiva solo se la condizione cond non è verificata.

// Trova un numero di tre cifre che non è preceduto da £
const testo = `€500 $400 £212 #700`;
const regex = /(?<!£)\d{3}/g;
const match = testo.match(regex);
console.log(match);

// Cercherà le lettere n non precedute da vocale e le lettere seguenti
const testo = `il cane, la faina, lo gnu, gli emù nello stagno`;
const regex = /(?<![aiuoe])n\w+/g;
const match = testo.match(regex);
console.log(match);

(?>cond) Gruppo atomico

Sottoespressione indipendente, cioè l’espressione viene considerata singolarmente senza considerare altre cose. Con un esempio torna tutto più chiaro:

• a(bc|b)c troverà sia la stringa abcc (a seguita da bc seguito da c) che la stringa abc (a seguita da b seguita da c)
• a(?>bc|b)c troverà invece solamente la stringa abcc in quanto in abc troverà la lettera a seguita dal gruppo atomico bc e non troverà la c finale.

Non è disponibile in javaScript ma può essere emuluta con (?=(?:cond))\1:

// Gruppo atomico in javascript
const testo = `abcc abc abcc abc abc abcc`;
const regex = /a(?=(bc|b))\1c/g;
const match = testo.match(regex);
console.log(match);

Ecco la spiegazione :

         ╔═══╗╔═════╗╔════════╗╔═══╗╔════╗╔═══╗ ┌─────────┐
         ║ a ║║ (?= ║║ (bc|b) ║║ ) ║║ \1 ║║ c ╟─┤Lettera c│
         ╚═╤═╝╚══╤══╝╚══╤═════╝╚═╤═╝╚═╤══╝╚═══╝ └─────────┘
┌──────────┴─┐   │   ┌──┴────┐   │  ┌─┴─────────────┐      
│ Lettera a  │   │   │Gruppo1│   │  │ Rif. gruppo 1 │      
└────────────┘   │   └───────┘   │  └───────────────┘      
    ┌────────────┴─────┐      ┌──┴─────────────┐           
    │ Inizio lookahead │      │ Fine lookahead │           
    │ negativa         │      │ negativa       │           
    └──────────────────┘      └────────────────┘           
                                                           
                                                           

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!