Un tester di regex che mostra come funziona
Questo tester di regex gratuito esegue la tua espressione regolare sul testo di esempio mentre digiti ed evidenzia ogni corrispondenza. Sotto l'evidenziazione trovi una tabella dei gruppi di cattura, un'anteprima live della sostituzione e una spiegazione in linguaggio semplice di ogni token, così puoi capire perché un pattern trova corrispondenze, non solo se le trova. Il motore è quello JavaScript integrato nel browser, quindi i risultati sono gli stessi di Chrome, Node.js, Deno e del codice TypeScript.
Il tester funziona anche come semplice generatore di regex: carica uno dei pattern comuni, crea un pattern "una qualsiasi di queste parole" da un elenco oppure esegui l'escape di una stringa letterale, così punti e parentesi quadre perdono il loro significato speciale. Il testo non lascia mai la pagina, un aspetto importante quando esegui test su log, dati dei clienti o token.
Scheda rapida delle espressioni regolari
| Token | Significato |
|---|---|
| . | Qualsiasi carattere eccetto un'interruzione di riga (qualsiasi carattere con il flag s) |
| \d \w \s | Cifra, carattere di parola (a-z, A-Z, 0-9, _), spazio bianco. Le versioni maiuscole significano "non". |
| [abc] [^abc] [a-z] | Un carattere appartenente a un insieme, non appartenente a un insieme o appartenente a un intervallo |
| ^ $ | Inizio e fine del testo, o di ogni riga con il flag m |
| \b | Confine di parola: il limite tra un carattere di parola e qualsiasi altra cosa |
| * + ? {2,5} | Zero o più, uno o più, opzionale, da 2 a 5 volte |
| *? +? | Versioni lazy: corrispondono alla quantità minima possibile |
| (x) (?:x) (?<name>x) | Gruppo di cattura, gruppo non catturante, gruppo denominato |
| a|b | a oppure b |
| (?=x) (?!x) (?<=x) (?<!x) | Lookahead, lookahead negativo, lookbehind, lookbehind negativo |
| \1 \k<name> | Riferimento all'indietro: lo stesso testo corrisposto in precedenza da un gruppo |
Flag nelle espressioni regolari JavaScript
g trova tutte le corrispondenze invece di fermarsi alla prima. i ignora le maiuscole e le minuscole. m fa funzionare ^ e $ su ogni riga. s consente a . di corrispondere alle interruzioni di riga. u attiva il supporto Unicode completo, incluso \p{L} per qualsiasi lettera in qualsiasi lingua e la gestione corretta delle emoji. y (sticky) corrisponde solo nella posizione corrente, caratteristica utile nei tokenizzatori. d aggiunge gli indici di inizio e fine per ogni gruppo e v è un successore più rigido di u che consente operazioni sugli insiemi all'interno delle classi di caratteri.
Gruppi e sostituzioni
Le parentesi hanno due funzioni: raggruppano una parte del pattern in modo che un quantificatore si applichi all'intera parte e catturano il testo per usarlo in seguito. In una stringa di sostituzione, $1 inserisce il primo gruppo, $<name> un gruppo denominato, $& l'intera corrispondenza e $$ un simbolo del dollaro letterale. Ad esempio, il pattern (\w+)@(\w+) con la sostituzione $2: $1 diventa ada@home in casa: ada. Se ti serve solo raggruppare, usa (?:...): è più veloce e mantiene stabili i numeri dei gruppi.
Espressioni regolari JavaScript rispetto a PCRE e Python
La maggior parte della sintassi è condivisa, ma alcune differenze possono causare sorprese quando si copia un pattern tra linguaggi:
- JavaScript non ha quantificatori possessivi (
a++) o gruppi atomici. PCRE (PHP e molti editor) lo fa. - Python denomina i gruppi come
(?P<name>...); JavaScript usa(?<name>...). - I flag inline come
(?i)all'inizio di un pattern funzionano in Python e PCRE. JavaScript ha aggiunto solo di recente gruppi di modificatori come(?i:...), quindi è preferibile usare i pulsanti dei flag. - In JavaScript,
$senza il flag m corrisponde solo alla fine assoluta; in Python$corrisponde anche prima di un'interruzione di riga finale. - Senza il flag u, JavaScript tratta un'emoji come due caratteri.
Se scrivi query SQL o formule per fogli di calcolo, le stesse idee si ritrovano in REGEXP e REGEXMATCH. Il generatore di query SQL e il generatore di formule Excel ti aiutano in questo.
Evita il backtracking catastrofico
Alcuni pattern richiedono un tempo esponenziale su testi che quasi corrispondono. L'esempio classico è (a+)+$ su una lunga sequenza di caratteri a seguita da un carattere diverso: il motore prova ogni modo possibile di dividere la sequenza tra il quantificatore interno e quello esterno. In produzione, questo può bloccare una pagina o mandare in crash un server, un problema noto come ReDoS. Questo tester esegue il tuo pattern in un worker in background e lo interrompe dopo due secondi, così visualizzi un avviso invece di una scheda bloccata. Per correggere un pattern lento, evita di annidare quantificatori sugli stessi caratteri, rendi le alternative mutuamente esclusive e ancora il pattern quando possibile.
Consigli per scrivere espressioni regolari facili da mantenere
- Parti da testo campione reale, incluse le righe che NON devono corrispondere.
- Ancora i pattern di convalida con
^e$, altrimenti\d{5}corrisponde anche all'interno di 123456. - Preferisci classi specifiche come
[^"]*sopra.*. - Usa gruppi denominati, così il codice che legge il risultato è autoesplicativo.
- Non usare le espressioni regolari per convalidare completamente email, URL o HTML. Usale per trovare i candidati, poi controllali correttamente.
Trasforma i tuoi casi di espressioni regolari in test unitari con il generatore di casi di test oppure scopri altri generatori e strumenti AI gratuiti.
Domande frequenti
Quale variante delle espressioni regolari usa questo tester?
Utilizza il motore JavaScript (ECMAScript) integrato nel browser, quindi i risultati corrispondono a quelli di Chrome, Node.js, Deno e TypeScript. La maggior parte della sintassi è condivisa con PCRE e Python, ma funzionalità come i quantificatori possessivi o i gruppi denominati in stile Python non sono supportate.
Il testo che testo viene inviato da qualche parte?
No. Il pattern e il testo vengono elaborati all'interno di questa pagina. Nulla viene caricato, registrato o memorizzato su un server. Le impostazioni vengono ricordate solo nel tuo browser.
Perché la mia espressione regolare trova solo la prima corrispondenza?
Attiva il flag g (globale). Senza di esso, JavaScript si ferma dopo la prima corrispondenza. Se ^ e $ devono funzionare su ogni riga, attiva anche il flag m (multilinea).
Cosa succede se il mio pattern è troppo lento?
Il tester esegue il pattern in un worker in background e lo interrompe dopo due secondi. Questo protegge la pagina dal backtracking catastrofico, che di solito deriva da quantificatori annidati come (a+)+.
Il generatore di espressioni regolari è basato sull'AI?
No. La libreria di pattern e gli strumenti di supporto sono basati su regole: caricano pattern testati, eseguono l'escape del testo letterale e combinano un elenco di parole in un unico pattern. Per i pattern scritti a partire da una descrizione in linguaggio naturale, consulta lo strumento Generatore di espressioni regolari con AI.