Regex Tester
| # | Indice | Corrispondenza | Gruppi |
|---|---|---|---|
| 1 | 5 | 42 | — |
| 2 | 14 | 7 | — |
Pattern comuni
Come funziona
Scrivi l'espressione regolare in alto, scrivi o incolla il testo da provare sotto, e lo strumento evidenzia ogni corrispondenza mentre digiti. Sotto il testo una tabella elenca ogni corrispondenza con il numero, l'indice del carattere in cui inizia, la sottostringa trovata e i gruppi di cattura nell'ordine in cui compaiono (i gruppi con nome sono inclusi nella stessa sequenza). Il pulsante Copia le corrispondenze le copia tutte, separate da un a capo o da una virgola. I pattern vengono compilati con il motore `RegExp` nativo del browser, quindi quello che vedi qui è esattamente quello che vedrà il tuo codice JavaScript, Node o Deno in produzione.
Se non vuoi partire da zero, la sezione Pattern comuni carica un esempio pronto per email, URL, telefono, indirizzo IP, data gg/mm/aaaa e colore esadecimale, con pattern, flag e testo di prova.
Un'espressione regolare è un piccolo linguaggio per descrivere schemi di testo. I mattoni che usi di continuo:
• `.` trova qualsiasi carattere tranne l'a capo • `\d` trova una cifra (0–9), `\D` un carattere che non è una cifra • `\w` trova un carattere di parola (lettere, cifre, underscore), `\W` uno che non lo è • `\s` trova uno spazio bianco (spazio, tab, a capo), `\S` tutto il resto • `[abc]` trova a, b o c. `[a-z]` è un intervallo. `[^abc]` nega l'insieme • `+` è una o più volte. `*` zero o più. `?` zero o una. `{3}` esattamente 3. `{2,5}` da 2 a 5. `{2,}` 2 o più • `^` è l'inizio della riga o del testo, `$` la fine • `\b` è un confine di parola, `\B` un punto che non lo è • `(...)` è un gruppo di cattura. `(?:...)` un gruppo che non cattura. `(?<nome>...)` un gruppo con nome • `(?=...)` è un lookahead. `(?!...)` un lookahead negativo. `(?<=...)` un lookbehind. `(?<!...)` un lookbehind negativo • `|` è l'alternativa (oppure)
I flag (le lettere dopo la `/` di chiusura) cambiano il comportamento di tutto il pattern: `g` trova tutte le corrispondenze invece della prima, `i` ignora maiuscole e minuscole (A = a), `m` fa corrispondere `^` e `$` all'inizio e alla fine di ogni riga invece che di tutto il testo, `s` fa trovare a `.` anche gli a capo, `u` attiva il supporto Unicode completo (indispensabile per emoji e caratteri non latini), `y` cerca solo a partire dalla posizione esatta di lastIndex.
La trappola da conoscere è il backtracking catastrofico. Pattern con quantificatori annidati come `(a+)+$`, applicati a un testo lungo che quasi corrisponde, possono metterci minuti a fallire, perché il motore prova ogni possibile suddivisione. La soluzione è evitare l'annidamento e riscrivere il pattern (`a+$` funziona benissimo). Se la scheda del browser si blocca quando incolli un pattern, il motivo è quasi sempre questo.
Lo strumento lavora tutto lato client: pattern e testo vengono compilati ed eseguiti dal motore RegExp del tuo browser. Niente lascia il tuo dispositivo, e conta, perché per provare una regex si usano spesso indirizzi email veri, token di autenticazione, estratti di log o dati personali.
Domande frequenti
Cos'è un'espressione regolare?
- È un pattern che descrive un insieme di stringhe. I mattoni più comuni: . (qualsiasi carattere), \d (cifra), \w (carattere di parola), + (una o più volte), * (zero o più), ^ (inizio riga), $ (fine riga), [] (insieme di caratteri), () (gruppo di cattura). Per esempio \d{2}/\d{2}/\d{4} trova date come 25/12/2025.
Che sintassi regex supporta?
- Tutta la sintassi regex standard di JavaScript, perché lo strumento usa il motore RegExp integrato nel browser. Questo include lookahead, lookbehind, gruppi con nome ed escape delle proprietà Unicode.
Cosa vogliono dire i flag g, i, m, s, u e y?
- g = globale (trova tutte le corrispondenze, non solo la prima), i = ignora maiuscole e minuscole (A trova anche a), m = multiriga (^ e $ valgono per ogni riga, non solo per l'intero testo), s = dotAll (. trova anche gli a capo), u = Unicode (supporto Unicode completo), y = sticky (cerca solo dalla posizione esatta).
Perché la mia regex non trova corrispondenze su più righe?
- Attiva il flag m (multiriga) se il pattern usa le ancore ^ o $, così corrispondono all'inizio e alla fine di ogni riga invece che dell'intero testo. Ricorda anche che il punto non trova gli a capo: se ti serve, attiva il flag s (dotAll).
Perché la scheda del browser si blocca con una certa regex?
- Quasi sicuramente è backtracking catastrofico. Pattern come (a+)+$ o (.*)*$, su un testo che quasi corrisponde, esplodono in modo esponenziale perché il motore prova ogni possibile suddivisione. La soluzione è riscrivere il pattern senza quantificatori annidati: (a+)+$ e a+$ trovano le stesse stringhe, ma il secondo non si blocca.
Come si usano i gruppi di cattura nelle regex?
- Metti tra parentesi la parte che vuoi tenere, e ottieni un gruppo numerato. (\d{4})-(\d{2})-(\d{2}) applicato a “2026-04-18” cattura “2026”, “04” e “18” come gruppi 1, 2 e 3, e la colonna Gruppi della tabella li mostra in quest'ordine. Puoi dare un nome a un gruppo con (?<anno>\d{4}) e richiamarlo per nome nelle sostituzioni o nel codice, e usare (?:...) quando ti serve raggruppare senza catturare.
Il mio testo viene inviato da qualche parte?
- No. Il pattern viene compilato ed eseguito in locale con il motore RegExp nativo del browser. Né il pattern né il testo di prova lasciano il tuo dispositivo, e conta, perché spesso si provano regex su indirizzi email veri, token o estratti di log.
Regex comuni: esempi pronti da copiare
Pattern collaudati per le cose che gli sviluppatori cercano più spesso. Sono tutti compatibili con JavaScript (usali così come sono in `new RegExp(...)` o `/.../flag`). Aggiungi il flag `i` dove ti serve ignorare maiuscole e minuscole.
| Cosa trova | Pattern | Esempi | Note |
|---|---|---|---|
| Email (pragmatica) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ | alice@example.com, bob+tag@a.co | Non è rigorosa come la RFC 5322, ma accetta circa il 99% degli indirizzi reali senza falsi negativi. Il pattern RFC completo è lungo 6.000 caratteri e scarta email valide: qui il pragmatismo vince |
| URL (http/https) | https?:\/\/[\w\-]+(\.[\w\-]+)+[\/\w\-\.~:?#\[\]@!$&'()*+,;=%]* | https://example.com/path?q=1 | Trova la maggior parte degli URL http(s). Per analizzarli a fondo usa l'API URL (`new URL(s)`) |
| Indirizzo IPv4 | \b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b | 192.168.1.1, 10.0.0.255 | Controlla che ogni ottetto sia ≤ 255. Per “4 numeri separati da punti” basta `\b\d{1,3}(\.\d{1,3}){3}\b` |
| IPv6 (tollerante) | \b(?:[A-Fa-f0-9]{1,4}:){7}[A-Fa-f0-9]{1,4}\b | 2001:db8::1, ::1 (con compressione) | Un IPv6 rigoroso con tutte le forme richiede circa 150 caratteri; questa forma pragmatica copre il caso completo non compresso |
| Codice fiscale | ^[A-Z]{6}\d{2}[A-EHLMPRST]\d{2}[A-Z]\d{3}[A-Z]$ | RSSMRA80A01H501Z | Controllo della struttura, non del carattere di controllo. 16 caratteri, maiuscoli |
| Partita IVA UE (generica) | ^[A-Z]{2}[A-Z0-9]{2,12}$ | IT12345678901, DE123456789 | Solo struttura. Per una verifica reale usa il servizio VIES |
| UUID v4 | ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$ | f47ac10b-58cc-4372-a567-0e02b2c3d479 | Usa il flag `i` per le maiuscole. Il `4` e `[89ab]` impongono la specifica v4 |
| Colore esadecimale (#abc / #aabbcc) | ^#(?:[\dA-Fa-f]{3}|[\dA-Fa-f]{6}|[\dA-Fa-f]{8})$ | #fff, #1A73E8, #80ffffff | Accetta 3, 6 e 8 cifre (con canale alfa) |
| Data ISO (AAAA-MM-GG) | ^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$ | 2026-04-18, 2026-12-31 | Solo struttura: non esclude il 30 febbraio. Abbinala a `Date.parse()` per una verifica completa |
| Data e ora ISO (con Z) | ^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$ | 2026-04-18T14:32:00Z | ISO 8601 con millisecondi e fuso Z facoltativi |
| Ora 24 ore HH:MM | ^([01]\d|2[0-3]):[0-5]\d$ | 09:30, 23:59 | Aggiungi `:[0-5]\d` in fondo per HH:MM:SS |
| Password robusta (8+, mista) | ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$ | P@ssw0rd, MyT@xes1 | I lookahead impongono almeno una minuscola, una maiuscola, una cifra e un carattere speciale. Le linee guida attuali preferiscono la lunghezza alla composizione |
| Slug (sicuro per URL) | ^[a-z0-9]+(?:-[a-z0-9]+)*$ | my-blog-post, hello | Lettere minuscole, cifre e trattini. Niente trattini all'inizio, alla fine o doppi |
| Riga vuota o di soli spazi | ^\s*$ | (vuota), (solo spazi) | Con il flag `m` trova ogni riga vuota di un testo su più righe |
| Spazi iniziali e finali | ^\s+|\s+$ | hello | Usalo con `.replace(/^\s+|\s+$/g, '')`, equivale a `String.trim()` |
| Telefono (internazionale, tollerante) | ^\+?[1-9]\d{1,14}$ | +393331234567, 14155551212 | Formato E.164, prefisso internazionale facoltativo. Per una verifica rigorosa per paese usa libphonenumber |
| Solo cifre di carta di credito (tollerante) | ^\d{13,19}$ | 4111111111111111 | Controlla solo la lunghezza. Per una verifica reale usa l'algoritmo di Luhn |
| Link Markdown | \[([^\]]+)\]\(([^)]+)\) | [Click](https://x.com) | Il gruppo 1 è il testo, il gruppo 2 l'URL. Non gestisce parentesi quadre annidate: è un limite, non un bug |
| Tag HTML (tollerante) | <\/?[a-z][\w-]*(?:\s+[\w-]+(?:="[^"]*"|='[^']*'|=\S+)?)*\s*\/?> | <a href="x"> | Non usare le regex per analizzare HTML qualsiasi: in produzione usa DOMParser. Per estrarre dati dai log va bene |
I pattern sono compatibili con JavaScript (regex ECMAScript 2018+) e sono provati con il motore `RegExp` nativo di JavaScript. Le implementazioni PCRE, Python e Java possono comportarsi diversamente nei casi limite (soprattutto su lookbehind e proprietà Unicode).