Come usare le espressioni regolari (regex): guida completa per sviluppatori

Le espressioni regolari (regex o regexp) sono pattern di ricerca che permettono di trovare, validare e trasformare testo con grande precisione. Sono fondamentali nello sviluppo software, nell'amministrazione di sistemi e nell'elaborazione dei dati.

Una regex e, in pratica, una sequenza di caratteri che descrive un modello. Con una sola espressione puoi risolvere controlli che altrimenti richiederebbero molte condizioni nel codice.

Usi comuni:

• Validazione dati: email, telefono, URL, CAP e altri formati
• Cerca e sostituisci: trovare pattern in testi lunghi e sostituirli rapidamente
• Estrazione dati: recuperare informazioni da log e testi non strutturati
• Analisi log: individuare errori, IP, codici e rotte
• Linting e formattazione: applicare convenzioni sul codice
• Routing web: definire pattern di URL nei framework

Le regex sono supportate in quasi tutti i linguaggi di programmazione: JavaScript, Python, Java, C#, PHP, Ruby, Go, Rust e molti altri. Sono usate anche in strumenti come grep, sed e awk.

Se vuoi esercitarti mentre leggi, apri il nostro strumento di test regex in un'altra scheda.

La sintassi regex combina caratteri letterali, cercati esattamente come sono, e metacaratteri, che hanno un significato speciale.

Caratteri letterali: lettere, numeri e molti simboli vengono interpretati letteralmente. Il pattern gatto trova la parola "gatto".

Metacaratteri principali:

Metacarattere	Significato	Esempio	Corrisponde a
.	Qualsiasi carattere tranne il ritorno a capo	g.to	"gatto", "gito", "g3to"
^	Inizio di riga/stringa	^Ciao	Solo all'inizio
$	Fine di riga/stringa	mondo$	Solo alla fine
*	0 o piu ripetizioni	ab*c	"ac", "abc", "abbc"
+	1 o piu ripetizioni	ab+c	"abc", "abbc"
?	0 o 1 ripetizione	colou?r	"color", "colour"
|	Alternativa	gatto|cane	"gatto" o "cane"
\	Escape	\.	Un punto letterale

Per cercare un metacarattere come testo, devi precederlo con \. Ad esempio \., \* o \\.

Esempio pratico: per trovare "prezzo: $9.99" puoi usare prezzo: \$9\.99.

Le classi di caratteri definiscono insiemi di caratteri validi in una certa posizione del pattern.

Pattern	Significato	Esempio
[abc]	a, b o c	"a", "b", "c"
[a-z]	Qualsiasi lettera minuscola	"a", "m", "z"
[A-Z]	Qualsiasi lettera maiuscola	"A", "M", "Z"
[0-9]	Qualsiasi cifra	"0", "5", "9"
[a-zA-Z0-9]	Qualsiasi carattere alfanumerico	"a", "3", "Z"
[^0-9]	Qualsiasi carattere che non sia cifra	"a", "!", " "

Scorciatoie comuni: \d per le cifre, \w per i caratteri di parola, \s per gli spazi bianchi e le versioni maiuscole per la negazione.

Confine di parola: \bgatto\b trova la parola completa "gatto", ma non "gattino".

Esempio pratico: ^[a-zA-Z0-9-]+$ valida una stringa composta solo da lettere, numeri e trattini.

I quantificatori indicano quante volte deve comparire l'elemento precedente.

Quantificatore	Significato	Esempio	Match
*	0 o piu volte	\d*	"", "5", "123"
+	1 o piu volte	\d+	"5", "123"
?	0 o 1 volta	-?\d+	"42", "-42"
{n}	Esattamente n volte	\d{4}	"2026"
{n,}	n o piu volte	\d{2,}	"12", "123"
{n,m}	Tra n e m volte	\d{2,4}	"12", "1234"

Per impostazione predefinita i quantificatori sono greedy e cercano di catturare il massimo. Se aggiungi ?, diventano lazy e catturano il minimo necessario.

Nel testo <b>Ciao</b> e <b>Mondo</b>, <b>.*</b> prende tutto, mentre <b>.*?</b> separa i due blocchi.

Esempio pratico: ^\d{5}(-\d{4})?$ valida un CAP statunitense con estensione opzionale.

I gruppi servono per organizzare parti del pattern, catturare sotto-risultati e riutilizzarli in seguito.

Sintassi	Tipo	Descrizione
(pattern)	Gruppo di cattura	Raggruppa e salva il match
(?:pattern)	Gruppo non catturante	Raggruppa senza salvare
(?<nome>pattern)	Gruppo nominato	Cattura con un nome
\1, \2	Backreference	Riferimento a un gruppo precedente

Esempio: (\d{4})-(\d{2})-(\d{2}) divide una data ISO in anno, mese e giorno.

I gruppi nominati come (?<year>\d{4}) migliorano la leggibilita.

Le backreference sono utili per trovare parole duplicate o virgolette coerenti, per esempio con (\w+)\s+\1 o (['"])(.*?)\1.

Alternanza: (https?|ftp):// corrisponde a "http://", "https://" o "ftp://". Puoi provarla nel nostro tool regex.

Lookahead e lookbehind verificano se un certo pattern appare prima o dopo la posizione corrente, senza consumare caratteri.

Sintassi	Nome	Significato
(?=pattern)	Positive lookahead	Il pattern deve comparire dopo
(?!pattern)	Negative lookahead	Il pattern non deve comparire dopo
(?<=pattern)	Positive lookbehind	Il pattern deve comparire prima
(?<!pattern)	Negative lookbehind	Il pattern non deve comparire prima

Esempio 1: ^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$ valida una password robusta.

Esempio 2: (?<=\$)\d+\.\d{2} estrae prezzi senza il simbolo di valuta.

Esempio 3: \w+(?!\s*:) trova parole non seguite da due punti.

Esempio 4: (?<!-)\b\d+\b intercetta solo numeri positivi. A seconda del motore regex, il lookbehind puo avere limitazioni.

Qui trovi alcuni pattern regex molto usati. Per formati complessi come l'email, e comunque consigliabile aggiungere una validazione lato server.

1. Email: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

2. Telefono internazionale (E.164): ^\+?[1-9]\d{1,14}$

3. URL: ^https?:\/\/[\w.-]+(?:\.[a-zA-Z]{2,})(?:\/[\w.~:/?#\[\]@!$&'()*+,;=-]*)?$

4. IPv4: ^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$

5. Data ISO: ^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$

6. Colore esadecimale CSS: ^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$

Puoi provare e rifinire questi pattern con il nostro strumento regex e usare anche il validatore JSON per strutture piu grandi.

Per padroneggiare le regex e importante conoscere i flag e seguire alcune buone pratiche di prestazione e manutenzione.

Flag	Nome	Effetto
g	Global	Trova tutte le occorrenze
i	Case insensitive	Ignora maiuscole e minuscole
m	Multiline	^ e $ funzionano per riga
s	Dotall	Il punto include anche le nuove righe
u	Unicode	Supporto Unicode completo

In JavaScript si usa /pattern/flags; in Python, ad esempio, re.compile(r'pattern', re.IGNORECASE | re.MULTILINE).

• Evita il backtracking catastrofico: pattern ambigui come (a+)+$ possono essere molto costosi
• Sii specifico: [a-z]+ e spesso meglio di .+
• Usa ancore: ^ e $ limitano la ricerca
• Preferisci gruppi non catturanti: (?:...) quando non devi salvare il match
• Compila la regex: se verra riutilizzata molte volte

Commenta le regex complesse, testa casi positivi e negativi e non usare regex per fare parsing profondo di HTML, XML o JSON. Per esercitarti usa il nostro tool regex.