Tester Regex gratuito — Debug e match dei pattern online
Testa pattern regex all'istante su qualsiasi testo. Evidenziazione delle corrispondenze, gruppi di acquisizione, anteprima di sostituzione e split. Espressioni regolari in JavaScript, 100% private, senza registrazione.
Cos'è un Tester Regex?
Un tester regex (tester di espressioni regolari) è uno strumento che ti lascia scrivere un pattern regex, incollare un pezzo di testo di prova e vedere esattamente cosa corrisponde al pattern — con gruppi di acquisizione, anteprima di sostituzione e scomposto dei flag — senza ricompilare codice o eseguire uno script. Per gli sviluppatori, accorcia il ciclo da minuti a millisecondi: ritocca il pattern, guarda gli highlight muoversi, spedisci la regex con fiducia.
Un'espressione regolare è un linguaggio compatto per descrivere pattern testuali. `\d+` corrisponde a una o più cifre. `[A-Za-z_]\w*` corrisponde a un tipico identificatore. `(?
Questo tester gira il motore RegExp nativo ECMA-262 incluso in ogni browser moderno — lo stesso motore che chiami da JavaScript, TypeScript, Node.js, Deno o Bun. Questo significa: gruppi di acquisizione (numerati e nominati con `(? Cosa fa emergere il tester oltre alle corrispondenze grezze: il pannello Corrispondenze e gruppi di acquisizione elenca ogni match con i suoi offset [start, end) e il valore di ogni gruppo di acquisizione — la stessa informazione che otterresti da `String.prototype.matchAll` con il flag /d, ma disposta per la scansione visiva. La scheda Replace mostra un'anteprima di sostituzione in tempo reale che supporta l'alfabeto completo dei template $1 / $& / $` / $' / $$ / $ Per la privacy: ogni operazione è locale. Il tuo pattern e il tuo testo di prova non lasciano mai la pagina — non vengono loggati, non vengono inviati a un servizio di analytics, non vengono memorizzati su disco. Solo le tue preferenze UI (scheda attiva + quali flag tieni di solito attivi) persistono in localStorage. Questo rende lo strumento sicuro per campioni di log redatti, pattern proprietari, configurazioni interne e pattern che includono indizi sullo schema dei tuoi dati. Rispetto a tester server-backed come regex101, la storia di privacy e latenza è strettamente migliore; il trade-off è il supporto a un solo flavour (solo JavaScript). Se sei nuovo a regex, il dropdown Pattern comuni include partenze rodate dalla battaglia: indirizzo email, URL, IPv4, UUID, colore hex, data ISO, numero di telefono US e un pattern per togliere gli spazi finali. Caricane uno, osserva le corrispondenze sul testo di esempio fornito, poi muta il pattern un carattere alla volta per sentire come risponde il motore. Abbina questo con lo strumento Diff di testo quando vuoi confrontare prima/dopo di una pulizia guidata da regex, con il Formattatore JSON quando il tuo input o l'output atteso è JSON, o con il codificatore URL quando le stringhe che fai corrispondere sono URL-encoded.
// The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';
for (const m of text.matchAll(pattern)) {
console.log(m.groups.year, m.groups.month, m.groups.day);
// → 2026 05 21
// → 2026 06 30
}
// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'
// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12] Funzionalità chiave
Evidenziazione delle corrispondenze in tempo reale
Ogni corrispondenza nel tuo testo di prova si illumina nell'istante in cui il tuo pattern viene parsato. Colori alternati rendono facile contare visivamente le corrispondenze adiacenti, e il badge del conteggio sopra il risultato ti dice il totale esatto — nessun pulsante Run, nessun delay di debounce oltre i 200ms.
Pannello laterale dei gruppi di acquisizione
Il pannello Corrispondenze e gruppi di acquisizione a destra elenca ogni match come una card con i suoi offset [start, end), il testo completo del match e ogni gruppo di acquisizione posizionale + nominato al suo interno. I gruppi nominati si etichettano come $
Anteprima Replace in tempo reale con $1 / $& / $
Passa alla scheda Replace per vedere la tua sostituzione applicata in tempo reale. Funziona l'intero alfabeto di sostituzione ECMAScript: $1..$N per posizionali, $
Split con confini regex
La scheda Split chiama String.prototype.split con la tua regex e mostra ogni parte come lista numerata. Le parti vuote sono renderizzate con un glifo ⏎ così puoi vedere come il motore ha gestito i delimitatori adiacenti — utile per il debug di pulizie di input CSV-like.
Spiegazione dei pattern (token-per-token)
La scheda Explain tokenizza il tuo pattern in chip colorati per classe (escape / quantificatore / classe di caratteri / gruppo / ancora / alternanza) e annota ogni chip con una descrizione di una riga. Rileggi la tua regex a te stesso prima di spedirla; usalo per code review o insegnamento.
ReDoS-safe (timeout wall-clock)
Ogni chiamata di match è avvolta in un budget di 250 millisecondi. Forme classiche di catastrophic backtracking come `(a+)+`, `(a|aa)+b` e quantificatori profondamente annidati abortiscono in modo pulito con un avviso Pattern in timeout — la pagina resta reattiva invece di bloccare la scheda. Rilevamento senza un sandbox server-side.
Libreria di pattern comuni
Partenze rodate dalla battaglia per gli otto pattern a cui gli sviluppatori ricorrono più spesso: email, URL, IPv4, UUID v4, colore hex, data ISO, numero di telefono US e rimozione degli spazi finali. Ognuno si carica con un campione corrispondente così vedi la regex funzionare prima di adattarla.
Condivisione tramite permalink (nessun upload)
Copia link codifica pattern + flag + testo di esempio nell'hash URL (#p=…&f=gim&t=…). I browser non trasmettono mai i fragment URL nelle richieste, quindi un link condiviso riproduce il tuo stato sulla macchina del destinatario senza toccare i server di go-tools.org. Autonomo e audit-friendly.
100% privato, solo browser
La tua regex e il testo di prova non lasciano mai il tuo dispositivo. Nessuna richiesta di rete, nessun logging, nessuna analytics su ciò che digiti. Verifica in DevTools → Network: zero richieste quando digiti. Sicuro per pattern proprietari, log redatti e qualunque testo non vorresti incollare in regex101.
Esempi guidati
Estrai ogni indirizzo email da un paragrafo
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g Incolla il pattern con il flag /g attivo, butta un paragrafo nel testo di prova e ogni email si illumina nella vista evidenziata. Il pannello Corrispondenze e gruppi di acquisizione a destra elenca ciascun indirizzo con i suoi offset [start, end) — utile quando passi la stessa regex a grep, sed o a un editor di codice.
Cattura le parti di una data con gruppi nominati
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g I gruppi nominati di ECMA-262 appaiono nel pannello a destra come $
Trova/sostituisci con back-reference $1
(\w+) (\w+)
Sostituzione: $2, $1 → Jack Doe → Doe, Jack
Due gruppi di acquisizione anonimi, template di sostituzione $2, $1, e la scheda Replace ti dà un'anteprima in tempo reale. $&, $`, $', $$ e $
Rimuovi gli spazi finali riga per riga
[ \t]+$
/[ \t]+$/gm
Combina i flag /g (global) e /m (multiline) in modo che $ si ancori alla fine di ogni riga, non solo alla fine dell'input. La scheda Replace con un'anteprima di sostituzione vuota mostra un diff pulito: tab e spazi finali spariscono, la prosa resta intatta. La stessa regex con il flag /s (dotAll) disattivato impedisce a . di attraversare i newline.
Rileva il catastrophic backtracking e sopravvivici
(a+)+b
Testo di prova: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac
I quantificatori + annidati formano un classico pattern ReDoS. In un tester ingenuo questo blocca la scheda. Qui il timeout a wall-clock scatta dopo 250ms, compare il banner Pattern in timeout e la pagina resta reattiva. Ancora il pattern, passa a un'alternanza non sovrapposta o usa idiomi atomic-like — e ritesta.
Split di una riga CSV-like con delimitatori misti
[,;|]\s*
alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]
Passa alla scheda Split. Qualsiasi virgola, punto e virgola o pipe (seguito da spazi opzionali) diventa un confine di parte. Utile per ripulire liste di tag copia-incollate, normalizzare input utente o pre-processare campi di log prima di un vero parser CSV — vedi Da CSV a JSON quando i dati sono davvero RFC 4180.
Come usare il Tester Regex
- 1
Digita il tuo pattern tra gli slash
Butta una qualsiasi espressione regolare ECMA-262 nel campo /…/. I pattern non validi si evidenziano in rosso con un messaggio del parser; i pattern validi passano al match in tempo reale.
- 2
Attiva i flag che ti servono
g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode), y (sticky), d (indices). Ogni chip si illumina quando è attivo; il readout a destra del pattern mostra il letterale canonico.
- 3
Incolla il tuo testo di prova
Le corrispondenze si evidenziano in colori alternati mentre digiti. Il pannello Corrispondenze e gruppi di acquisizione a destra elenca ogni match con offset [start, end) e il valore di ogni gruppo di acquisizione (i gruppi nominati sono etichettati $
). - 4
Cambia scheda per Replace, Split o Explain
Replace mostra l'anteprima di un template di sostituzione accanto all'input. Split affetta a ogni confine di match. Explain scompone il pattern token-per-token con una descrizione in italiano semplice per ogni elemento.
- 5
Copia il letterale o condividi un permalink
Copia /pattern/flags mette il letterale regex canonico negli appunti per l'uso diretto in JavaScript / TypeScript / Node. Copia link codifica lo stato completo in un hash URL (nessun upload) così un collega può riprodurlo localmente.
Errori comuni nelle regex
Hai dimenticato il flag /g e hai ottenuto una sola corrispondenza
Senza /g (o /y), il motore si ferma dopo la prima corrispondenza. I metodi match, matchAll, replace e split si comportano tutti diversamente attorno al flag globale. Attiva /g e riesegui; il conteggio sopra i risultati salta da 1 a N.
Pattern: /\d+/ → '1 22 333' dà solo ['1']
Pattern: /\d+/g → '1 22 333' dà ['1', '22', '333']
Quantificatore greedy ha consumato troppo
`.+` consuma il più possibile, quindi `<.+>` contro ` and ` cattura ` and `, non ``. Usa quantificatori lazy (`.+?`), classi di caratteri più restrittive (`[^>]+`) o ancora con lookaround.
Pattern: /<.+>/ → corrisponde a '<a> and <b>'
Pattern: /<[^>]+>/ → corrisponde a '<a>' e '<b>' separatamente
Catastrophic backtracking da quantificatori annidati
`(a+)+b` contro una lunga stringa che fallisce esplode esponenzialmente. Il banner Pattern in timeout scatta dopo 250ms; riscrivi per rimuovere l'annidamento: `a+b` fa lo stesso lavoro in tempo lineare. La simulazione di gruppo atomico `(?=(a+))\1b` è un'altra opzione.
Pattern: /(a+)+b/ su 'aaaaaaaaaaaaaaaaaaaaac' → timeout
Pattern: /a+b/ sullo stesso input → istantaneo 'nessuna corrispondenza'
Le ancore $ e ^ non si comportano come \A e \Z di Python
In JavaScript, `^` e `$` significano inizio-riga / fine-riga SOLO quando /m è attivo; altrimenti significano inizio-stringa / fine-stringa. `\A` e `\Z` di Python (che significano sempre confini di stringa) non esistono in JS. Attiva /m quando necessario.
Pattern: /^Error/ su un log multiriga senza /m → corrisponde solo alla prima riga
Pattern: /^Error/m sullo stesso input → corrisponde a ogni riga che inizia con Error
Hai usato $1 in una stringa ma chiamato replace con una funzione
`text.replace(re, '$1')` espande la back-reference. `text.replace(re, () => '$1')` passa la stringa letterale '$1' perché le funzioni non vedono i token di template. Dentro la funzione, i gruppi di acquisizione arrivano come argomenti posizionali.
text.replace(/(\w+)/, m => '$1') → produce il letterale '$1'
text.replace(/(\w+)/, (_, g1) => g1.toUpperCase()) → usa la cattura
I caratteri Unicode non corrispondono con \w o .
Il `\w` di default è `[A-Za-z0-9_]`. Per corrispondere a ogni lettera in ogni script, abilita /u e passa a `\p{Letter}` (`\p{L}`). Il punto si ferma anche ai newline per default — usa /s (dotAll) quando vuoi un vero qualsiasi-carattere.
Pattern: /\w+/ corrisponde a 'hello' ma non a 'héllo' o '你好'
Pattern: /\p{Letter}+/u corrisponde a tutti e tre Hai incollato un pattern PCRE; hai ottenuto un SyntaxError
JavaScript non supporta gruppi atomici `(?>...)`, quantificatori possessivi `a++`, modificatori inline `(?i)`, condizionali `(?(1)yes|no)` o `\A` / `\Z`. L'errore del parser nomina il costrutto offendente — riscrivi nell'equivalente supportato da JS (simulazione con lookaround, toggle del flag separato, alternanza).
Pattern: (?i)foo → SyntaxError: gruppo non valido
Pattern: foo con il flag /i attivato → stesso effetto
Chi usa questo strumento
- Valida input di form prima del rilascio
- Conferma che la tua regex per email / telefono / CAP / username corrisponda a ciò che ti aspetti — e rifiuti ciò che non vuoi — attraverso casi limite (nomi Unicode, plus-aliasing, formati internazionali) prima che la validazione raggiunga la produzione e rimbalzi utenti reali.
- Estrai dati da log e configurazioni
- Costruisci un pattern che estragga ID di richiesta, codici di stato, latenze o righe di stack trace da una porzione arbitraria di log. I gruppi nominati rendono i dati auto-documentanti; il pannello Corrispondenze mostra gli offset così puoi passare la stessa regex a `rg --replace` o `grep -oE` dopo.
- Trova/sostituisci in un codebase
- Bozza un pattern di refactor (es. `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`) qui, vedi l'anteprima della sostituzione su snippet rappresentativi, poi incolla la regex validata nel cerca/sostituisci a livello di progetto del tuo editor con fiducia.
- Controlla un pattern trovato online
- Hai incollato una regex da StackOverflow o da un blog? Buttala nella scheda Explain — ogni token viene annotato in italiano semplice. Intercetta problemi sottili (`.+?` dove volevi `.+`, ancore `^`/`$` mancanti, quantificatori accidentalmente greedy) prima che la regex finisca nel tuo codice.
- Insegna regex a un collega
- Apri la scheda Explain su un pattern funzionante e percorrilo token-per-token. La codifica a colori (escape / quantificatore / classe di caratteri / gruppo / ancora / alternanza) lascia che chi impara veda la forma strutturale della regex, non solo i caratteri.
- Porta un pattern tra linguaggi
- Hai una regex Python o PCRE che ti serve in JavaScript? Incollala qui. Se viene parsata, l'explainer ti mostra la semantica JS-equivalente; se no, l'errore del parser nomina il costrutto offendente (gruppi atomici, quantificatori possessivi, inline `(?i)`) così sai esattamente cosa riscrivere.
- Debug di una regex lenta in produzione
- Se una regex server è sospettata di catastrophic backtracking, incollala in questo tester con un campione dell'input. Il timeout wall-clock di 250ms scatta sui casi patologici, dandoti una diagnosi immediata prima di ricorrere a strumenti di profiling — e l'explainer indica la causa radice nel quantificatore annidato.
Note su motore e algoritmo
- Motore RegExp ECMA-262 (browser nativo)
- Usa `new RegExp(pattern, flags)` e il motore incluso in V8 / JavaScriptCore / SpiderMonkey — la stessa semantica regex che ottieni in JavaScript ovunque. I pattern che validano qui girano invariati in Node.js, Deno, Bun e ogni browser moderno.
- Iterazione dei match via String.matchAll
- L'iterazione globale usa `text.matchAll(regex)` invece di un loop manuale su lastIndex, così ogni match porta con sé i suoi gruppi di acquisizione, gruppi nominati e (con /d) gli indici [start, end]. I match a larghezza zero sono gestiti con l'avanzamento standard di +1 su lastIndex per evitare loop infiniti.
- Timeout wall-clock per la protezione ReDoS
- Un budget di 250 millisecondi avvolge ogni chiamata di match, replace e split. Il motore può comunque fare backtrack internamente su un singolo tentativo di match, ma l'iterazione esterna coopera con il budget — i pattern patologici abortiscono con `timedOut: true` e l'UI fa emergere un avviso invece di bloccare la scheda.
- Reimplementazione del template di sostituzione
- La scheda Replace fa il parsing manuale di $1..$N, $&, $`, $', $$ e $
invece di delegare a `String.replace`, così l'anteprima si comporta in modo identico su tutti i motori (Safari più vecchio, Node più vecchio) dove i template a gruppi nominati hanno casi limite. L'output è esattamente ciò che producono i motori JavaScript attuali. - Tokenizer del pattern per l'explainer
- La scheda Explain esegue un tokenizer scritto a mano che classifica ogni frammento del pattern (escape / metachar / quantificatore / classe di caratteri / apertura-gruppo / chiusura-gruppo / ancora / alternanza). I costrutti non familiari ricadono su `literal` con una nota generica così l'explainer non perde mai silenziosamente del contenuto.
- Permalink tramite hash URL (mai trasmessi)
- Lo stato condiviso è codificato nel fragment location.hash (`#p=…&f=…&t=…&tab=…`). I browser non trasmettono mai il fragment nelle richieste HTTP, quindi i server di go-tools.org ricevono zero dati quando viene aperto un permalink. L'idratazione avviene interamente sul dispositivo del destinatario.
Best practice per le regex
- Ancora i pattern quando intendi farlo
- `^pattern$` corrisponde a una stringa esatta; `pattern` corrisponde ovunque. La scelta sbagliata è il bug più comune nella validazione dei form: un `^` mancante lascia passare un `attacker.com/` iniziale oltre un controllo di dominio; un `$` mancante lascia passare spazzatura finale. Usa la scheda Match contro campioni deliberatamente rotti per confermare cosa viene rifiutato.
- Preferisci gruppi non-catturanti per la pura struttura
- `(?:foo|bar)+` e `(foo|bar)+` sono funzionalmente identici, ma il primo non alloca un gruppo di acquisizione. Ricorri a `(?:…)` ogni volta che il gruppo esiste solo per un quantificatore o un'alternanza — mantiene stabili i tuoi $1..$N numerati e risparmia una piccola quantità di lavoro al motore.
- Usa il flag /u per qualsiasi cosa oltre l'ASCII
- Senza /u, il punto e `\w` trattano i caratteri a coppia surrogata (emoji, code point non-BMP) come due unità UTF-16. Con /u, sono un code point ciascuno — ciò che percepiranno i tuoi utenti. /u abilita anche `\p{Letter}` e altri escape di proprietà. Default a /u per i nuovi pattern a meno che tu non abbia una ragione specifica per non farlo.
- Nomina i tuoi gruppi di acquisizione
- `(?
\d{4})-(? \d{2})` è auto-documentante. Sei mesi dopo quando rileggi la regex, `m.groups.year` è ovviamente l'anno — `m[1]` no. Anche i template di sostituzione con $ sopravvivono al riordino dei gruppi: i template posizionali si rompono nel momento in cui qualcuno aggiunge un altro gruppo. - Testa i casi di fallimento, non solo i successi
- Un tester regex è per i fallimenti. Conferma cosa il tuo pattern fa corrispondere, poi muta deliberatamente il testo di prova per vedere cosa non fa corrispondere — spazi iniziali, spazi finali, parti mancanti, parti extra, case sbagliato, script misti. I pattern che passano input validi ma accettano spazzatura sono i bug che la produzione espone per primi.
Domande frequenti
La mia regex o il testo di prova vengono inviati al vostro server?
Quale flavour di regex usa questo tester — PCRE, Python, Java, JavaScript?
Cosa fanno i flag g, i, m, s, u, y, d?
Come scrivo i gruppi di acquisizione e come ci faccio riferimento?
Come funzionano lookahead e lookbehind, e a cosa servono?
Perché la mia regex blocca il browser, e cos'è il catastrophic backtracking?
Come si differenzia questo tester regex da regex101.com?
Come faccio l'escape di caratteri speciali come . | ( ) [ ] { } * + ? ^ $ \?
Posso condividere una regex con un collega tramite link?
Il tester supporta Unicode, emoji e script non latini?
Qual è la differenza tra .match, .matchAll, .replace e .split con una regex?
Perché la mia regex Python o Java non funziona qui?
Esiste un limite massimo di dimensione del testo o di numero di corrispondenze?
Strumenti correlati
Vedi tutti gli strumenti →Confronta due testi — Diff
Elaborazione del testo
Confronta due testi all'istante nel browser. Vista affiancata, evidenziazione parola per parola, esportazione diff unificato, opzioni per ignorare maiuscole/spazi/righe vuote. 100 % browser — nessun upload.
Contatore di parole e caratteri gratuito
Elaborazione del testo
Conta parole, caratteri, frasi, paragrafi e tempo di lettura all'istante. Contatore di parole in tempo reale con controlli di limite per Twitter, meta description e Instagram. Gratuito, privato, senza registrazione.
Convertitore di Basi Numeriche — Bin, Hex, Ott, Dec
Strumenti di conversione
Converti istantaneamente tra binario, esadecimale, decimale, ottale e qualsiasi base (2-36). Strumento online gratuito e privato: tutta l'elaborazione avviene nel tuo browser.
Decodificatore e codificatore Base64
Codifica e formattazione
Decodifica e codifica Base64 online gratis. Conversione in tempo reale con pieno supporto UTF-8 ed emoji. 100% privato — gira nel tuo browser. Nessuna registrazione.
Generatore Crontab e Costruttore di Espressioni Cron
Data e ora
Genera, valida e decodifica espressioni cron online nel browser. Anteprima live delle prossime esecuzioni in ora locale o UTC. Sintassi POSIX a 5 campi, preset e descrizione in italiano.
Convertitore CSV in JSON
Codifica e formattazione
Converti CSV in JSON nel browser. RFC 4180, inferenza tipi, riga header, sicuro per big-int. 100% privato, nessun upload.