Come Testare un'Espressione Regolare Online (Con Esempi Reali)

Per testare un’espressione regolare si scrive il pattern tra i delimitatori / /, si scelgono i flag giusti per il caso d’uso, si esegue il match contro una stringa di prova reale e si verificano sia le corrispondenze evidenziate sia gli eventuali gruppi catturati, prima di incollare quel pattern in produzione. Saltare l’ultimo passaggio è il motivo per cui tante regex “funzionano sul mio computer” e poi falliscono silenziosamente su un input che nessuno aveva provato.

Pattern e flag: cosa fanno davvero

Un’espressione regolare comincia e finisce con una barra: /pattern/. Tutto quello che sta tra le due barre è la sequenza di caratteri, letterali e speciali, che il motore userà per cercare corrispondenze nel testo. Subito dopo la barra finale possono comparire uno o più flag, lettere singole che cambiano il comportamento del motore senza toccare il pattern stesso. Il tester regex di pluri.tools espone esattamente quattro flag:

• g (global): senza questo flag il motore si ferma alla prima corrispondenza trovata e ignora tutto il resto della stringa. Con g attivo, continua a cercare fino alla fine e restituisce ogni occorrenza.
• i (case-insensitive): rende il confronto insensibile a maiuscole e minuscole, quindi /ciao/i corrisponde sia a Ciao che a CIAO.
• m (multiline): cambia il significato di ^ e $. Senza m questi due simboli ancorano rispettivamente all’inizio e alla fine dell’intera stringa; con m attivo ancorano all’inizio e alla fine di ogni singola riga, utile quando si lavora su testo multi-riga come un file di log.
• s (dotAll): normalmente il punto . corrisponde a qualsiasi carattere tranne l’a-capo. Con s attivo, corrisponde anche ai ritorni a capo, il che serve quando si vuole far combaciare un blocco di testo che si estende su più righe.

A questi si aggiungono i gruppi di cattura. Racchiudere una parte del pattern tra parentesi tonde () non cambia cosa viene cercato, ma dice al motore “ricorda anche questo pezzo separatamente”. Ogni gruppo numerato compare poi nell’elenco dei risultati come Gruppo 1, Gruppo 2 e così via, nell’ordine in cui le parentesi aperte appaiono nel pattern. Se preferisci un nome invece di un numero, la sintassi (?<anno>\d{4}) crea un gruppo chiamato “anno” che puoi recuperare per nome nel codice, invece di doverti ricordare che era il terzo gruppo da sinistra.

Esempi pratici da copiare e adattare

Quattro pattern reali, con il comportamento esatto che dovresti aspettarti da ciascuno:

Pattern	Flag	Corrisponde	Non corrisponde	Cattura
^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$	nessuno	[email protected]	jane@example (manca il dominio di primo livello)	nessuno
#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})	g	#2F7BFF, #fff	#12G456 (G non è esadecimale)	Gruppo 1: 2F7BFF
\/(\w+)\/(\w[\w-]*)	g	/users/123, /products/abc-456	/users (manca il secondo segmento)	Gruppo 1: tipo di risorsa, Gruppo 2: id
^\d{4}-\d{2}-\d{2}$	nessuno	2026-07-11	07/11/2026 (formato sbagliato)	nessuno

Vale la pena scomporre due di questi pattern con più calma, perché è così che si impara davvero a leggere una regex invece di copiarla e sperare.

Prendi \/(\w+)\/(\w[\w-]*) con il flag g, pensato per validare percorsi tipo REST. Il primo \/ è una barra letterale con escape, perché nel contesto delimitato da / / una barra “nuda” chiuderebbe il pattern prima del previsto. Segue (\w+), un gruppo che cattura una o più lettere, cifre o underscore: questo è il segmento che identifica il tipo di risorsa, come users o products. Poi c’è di nuovo una barra letterale, e infine (\w[\w-]*), un secondo gruppo che richiede di iniziare con un carattere di parola e può proseguire con lettere, cifre, underscore o trattini: questo cattura l’identificatore, che può essere un numero puro come 123 o uno slug come abc-456. Applicato a /users/123, il Gruppo 1 vale users e il Gruppo 2 vale 123; applicato a /products/abc-456, i due gruppi valgono products e abc-456. È esattamente la coppia di valori che serve per instradare una richiesta verso il controller giusto con l’id giusto, senza dover fare uno split manuale della stringa e sperare che non ci siano barre in più. Il flag g qui conta doppio se il pattern viene applicato a un intero file di log di accessi: senza g, matchAll o replace si fermerebbero al primo URL trovato e ignorerebbero tutte le richieste successive nello stesso testo.

Ora #([0-9a-fA-F]{6}|[0-9a-fA-F]{3}) con g, pensato per estrarre colori esadecimali da un foglio di stile. Il # iniziale è letterale, il cancelletto che precede ogni colore CSS. Dentro le parentesi c’è un’alternanza, il simbolo | che significa “questo oppure quello”: a sinistra [0-9a-fA-F]{6}, esattamente sei caratteri esadecimali, il formato lungo come 2F7BFF; a destra [0-9a-fA-F]{3}, esattamente tre, il formato corto come fff. Il motore prova prima l’alternativa a sei cifre e, se non trova un match completo, ripiega su quella a tre. Su #12G456 nessuna delle due alternative regge, perché G non è un carattere esadecimale valido, quindi correttamente non c’è corrispondenza. Qui il flag g non è un dettaglio opzionale: senza di esso, applicando il pattern a un file CSS con dieci colori diversi, il motore restituirebbe solo il primo e si fermerebbe, dando l’illusione che ci sia un solo colore nel documento. Con g attivo ottieni ogni occorrenza, e il Gruppo 1 di ciascuna ti dà il valore pulito del colore senza il cancelletto, pronto per essere raccolto in una lista e magari deduplicato per costruire una palette dei colori di brand effettivamente usati nel foglio di stile.

Provalo tu stesso

Scrivi il tuo pattern, incolla una stringa di prova e guarda in tempo reale cosa combacia e cosa no, direttamente qui sotto.

Tester di Espressioni Regolari

Gratis, senza registrazione, su qualsiasi dispositivo.

Apri lo strumento completo

Errori comuni e casi limite

Dimenticare il flag g. Senza di esso il regex si ferma alla prima corrispondenza, rompendo silenziosamente qualsiasi cosa si aspetti tutte le occorrenze, per esempio un “sostituisci tutto” che finisce per sostituire solo la prima istanza e lasciare intatte tutte le altre. È l’errore più frequente in assoluto perché il codice non genera nessun errore: semplicemente produce meno risultati di quelli attesi, ed è facile non accorgersene finché qualcuno non segnala il bug in produzione.

Il punto senza escape. Un . senza escape corrisponde a qualsiasi carattere, non a un punto letterale. Un pattern come 192.168.1.1 scritto direttamente come regex corrisponde anche a una stringa come 192X168X1X1, perché ogni punto viene interpretato come “un carattere qualsiasi” invece che come il carattere punto. Usa \. per un punto letterale: è una delle differenze più costose tra “sembra funzionare sui miei esempi” e “funziona davvero”.

Quantificatori avidi contro pigri. .* prende tutto il possibile, è avido per definizione, e può estendersi ben oltre quanto previsto. L’esempio classico è cercare un tag HTML: un pattern come <.*> applicato a un intero blocco di markup con più tag non si ferma al primo > che trova, ma corrisponde dal primo < fino all’ultimo > di tutto il blocco, inglobando tutto quello che sta in mezzo. La versione pigra .*? si ferma invece al primo punto possibile, il che nella maggior parte dei casi è quello che si voleva davvero ottenere.

Ancore mancanti. Senza ^ e $, un pattern può corrispondere come sottostringa in qualsiasi punto del testo, quindi un pattern di “validazione” senza ancore può far passare una stringa che contiene solo una parte valida, lasciando entrare input non validi. Un controllo email senza ^ all’inizio e $ alla fine potrebbe accettare testo prima [email protected] testo dopo come indirizzo valido, perché la porzione centrale combacia comunque. ^ e $ obbligano la corrispondenza sull’intera stringa, dall’inizio alla fine, senza scorciatoie.

Domande frequenti

Qual è la vera differenza tra usare il flag g e non usarlo? Senza g, i metodi come test() o match() restituiscono solo la prima occorrenza trovata e si fermano lì, anche se il pattern potrebbe corrispondere altre dieci volte nello stesso testo. Con g attivo, il motore continua a scansionare fino alla fine della stringa e restituisce ogni corrispondenza, il che è indispensabile per operazioni come estrarre tutti gli URL da un documento o sostituire ogni occorrenza di una parola.

Come faccio a far corrispondere un carattere speciale letterale come un punto, un dollaro o una parentesi? Anteponi una barra rovesciata, il carattere di escape: \. per un punto letterale, \$ per un dollaro letterale, \( e \) per parentesi letterali. Questo vale per tutti i caratteri che hanno un significato speciale nella sintassi regex, cioè . * + ? ^ $ { } ( ) | [ ] \. Se dimentichi l’escape, il motore interpreta quel carattere secondo il suo significato speciale invece che come il simbolo che avevi in mente.

Cos’è un gruppo non catturante, (?:…), e quando mi serve al posto di un normale gruppo (…)? Un gruppo non catturante raggruppa una parte del pattern, per esempio per applicarci un quantificatore o un’alternanza, senza aggiungerla all’elenco dei gruppi catturati nel risultato. Serve quando hai bisogno della struttura logica delle parentesi ma non ti interessa recuperare quel pezzo di testo separatamente: per esempio (?:https?:\/\/)?(\w+\.\w+) raggruppa il prefisso http:// o https:// opzionale senza catturarlo, mentre il dominio vero e proprio resta nel Gruppo 1. Usarlo tiene pulita la numerazione dei gruppi quando il pattern cresce e ha più parentesi solo strutturali.

Questo strumento invia il mio pattern o testo di test da qualche parte? No. Tutto viene eseguito nel browser tramite il motore JavaScript RegExp nativo: nessun dato, né il pattern né il testo di prova, viene inviato a un server. Puoi testare stringhe che contengono informazioni sensibili senza che lascino il tuo dispositivo.