Tester di espressioni regolari online

Scrivi un'espressione regolare e osserva immediatamente, man mano che digiti, le corrispondenze evidenziate nel testo di prova. I gruppi di cattura sono elencati per ogni corrispondenza e sono supportati tutti i flag JavaScript per le espressioni regolari. Ottimo strumento per creare e correggere i pattern prima di inserirli nel codice.

Che cos'è questo strumento?

Un'espressione regolare (regex) è un linguaggio di pattern compatto che consente di individuare, convalidare ed estrarre testo: un pattern per indirizzi e-mail può convalidare i dati inseriti in un modulo, \d{4}-\d{2}-\d{2} individua le date e i gruppi di cattura estraggono le parti desiderate. Quasi tutti i linguaggi di programmazione e gli editor supportano le espressioni regolari.

Questo tester utilizza il motore di espressioni regolari di JavaScript — lo stesso che gira su Node.js e su tutti i browser — quindi i pattern creati qui si comportano esattamente allo stesso modo nel codice JavaScript/TypeScript. La maggior parte dei pattern funziona inoltre senza modifiche anche in Python, Java e Go.

Perché usarlo?

Feedback in tempo reale: le corrispondenze vengono evidenziate in giallo man mano che si digita la sequenza.
Gruppi di cattura visualizzati per corrispondenza — scopri esattamente cosa conterranno $1 e $2.
Supporto completo dei flag: g (tutte le corrispondenze), i (ignora maiuscole/minuscole), m (più righe), s (il punto corrisponde al carattere di nuova riga), u (Unicode).
Visualizza messaggi di errore quando il pattern presenta un errore di sintassi.
Gratuito e riservato: il modello e il testo non lasciano mai il tuo browser.

Come si usa

Digita il tuo pattern tra i due caratteri / (non è necessario aggiungere il carattere di escape alle barre).
Modifica i flag nella casella dopo il secondo / — l'impostazione predefinita "g" individua tutte le corrispondenze.
Incolla qui sotto il testo di prova.
Le corrispondenze vengono evidenziate immediatamente; i gruppi di corrispondenze sono elencati sotto.
Se il modello non è valido, il messaggio di errore spiega qual è il problema.

Esempio

Input

Pattern: (\w+)@(\w+)\.com
Test string: Contact alice@example.com or bob@test.com

Risultato

✓ 2 matches
#1 groups: $1=alice  $2=example
#2 groups: $1=bob  $2=test

Le parentesi creano gruppi di cattura a cui è possibile fare riferimento come $1 e $2 nelle sostituzioni.

Consigli pratici

Come verificare la validità di un indirizzo e-mail inserito? ^[^\s@]+@[^\s@]+\.[^\s@]+$ è un modello permissivo che individua gli errori di digitazione più evidenti senza scartare indirizzi validi ma insoliti — per garantire la piena conformità allo standard RFC 5322 è necessaria una libreria, non una riga di codice.
Estrazione dei parametri di query da un URL: [?&]([^=]+)=([^&]*) con il flag -g, per poi leggere $1/$2 per ogni corrispondenza invece di separarli manualmente in base a & e =.
Stai per usare un pattern in .replace()? Provalo prima qui: ciò che viene evidenziato è esattamente ciò che .replace() modificherà, gruppi di cattura inclusi.
Analisi dei log su più righe (corrispondenza con un timestamp all'inizio di ogni riga)? Aggiungi il flag m in modo che ^ e $ fungano da ancore per ogni singola riga anziché per l'intera stringa.
Hai copiato un pattern da Python o PHP e qui non funziona? Controlla se sono presenti gruppi denominati (?P<name>...) — JavaScript usa (?<name>...), senza la P — o quantificatori possessivi (++, *+), che non esistono nelle espressioni regolari di JavaScript.

Uno strumento per testare le espressioni regolari in JavaScript, non uno generico

Questo strumento utilizza il motore RegExp integrato in JavaScript — lo stesso percorso di codice che sta dietro a `str.match(pattern)` o `pattern.test(str)` nella console di un browser o in Node.js. Ciò differisce dal test con PCRE (utilizzato da PHP e impostato di default da molti tester "universali" di espressioni regolari) o dal modulo re di Python: JavaScript non dispone di quantificatori possessivi né di gruppi atomici, e i gruppi di cattura denominati utilizzano (?<name>...) anziché (?P<name>...) come in PCRE/Python.

Se stai per inserire un pattern in JavaScript o TypeScript — ad esempio, nella convalida di un modulo, in un route matcher o in un parser di log — testarlo qui garantisce che non ci siano discrepanze: ciò che viene evidenziato in questa pagina corrisponde esattamente a ciò che la nuova funzione RegExp(pattern, flags) individua in fase di esecuzione.

Come si inserisce tutto questo nei flussi di lavoro reali

Un test con espressioni regolari raramente viene eseguito da solo. La sequenza tipica è la seguente: confermare il pattern qui, eseguire il comando .replace() effettivo nel proprio codice, quindi confrontare il testo prima e dopo per assicurarsi che la sostituzione abbia prodotto il risultato previsto e nient’altro.

L'estrazione di dati strutturati tramite gruppi di acquisizione spesso genera direttamente un output in formato JSON: formatta l'output estratto per verificare che sia stato analizzato nel modo previsto.

→ Differenze tra i testi · Formattatore JSON

Domande frequenti

Quale variante di espressione regolare utilizza questo tester?

JavaScript (ECMAScript), il motore presente in tutti i browser e in Node.js. La sintassi di base è portabile, ma alcune caratteristiche differiscono da un linguaggio all’altro: ad esempio, il supporto al lookbehind e la sintassi dei gruppi denominati variano in Python e Java.

Perché il mio pattern trova solo la prima corrispondenza?

Manca il flag g (globale). Senza g, un'espressione regolare si interrompe dopo la prima corrispondenza. Questo strumento utilizza g come impostazione predefinita: assicurati di non averlo rimosso.

Perché . non rispecchia le mie interruzioni di riga?

Per impostazione predefinita, il carattere . corrisponde a qualsiasi carattere eccetto i caratteri di nuova riga. Aggiungi il flag s (dotall) per far sì che il carattere . corrisponda anche ai caratteri di nuova riga, oppure utilizza [\s\S] come alternativa portabile.

Cosa significano i risultati del gruppo di acquisizione?

Ogni coppia di parentesi presente nel pattern cattura il testo a cui corrisponde. $1 rappresenta il primo gruppo, $2 il secondo e così via: sono questi i valori a cui si fa riferimento nelle operazioni di sostituzione e nel codice di estrazione.

Perché la mia espressione regolare è lenta o si blocca?

Probabile backtracking catastrofico, causato da quantificatori annidati come (a+)+ su un input non corrispondente. Riscrivi il pattern per evitare ripetizioni ambigue. Questo strumento limita il numero di corrispondenze a 1000 per garantire una buona reattività.