Guida rapida alle regex — Ogni token con esempi
Ogni token delle espressioni regolari con un esempio funzionante, il supporto in JavaScript, PCRE/PHP, Python, Go, Java e .NET e un link Provalo che apre il tester regex già compilato.
Ultima verifica: 2026-10-18 su ECMAScript 2025 (MDN), PCRE2 10.45, re di Python 3.14, regexp/syntax di Go 1.27, Pattern di Java 25 e il riferimento delle regex .NET. Fonti: MDN regular expressions, PCRE2 pattern syntax, Python re, Go regexp/syntax, Java Pattern, .NET regex quick reference.
Caratteri ed escape
La maggior parte dei caratteri corrisponde a se stessa. Questi dodici hanno un significato speciale e richiedono una barra rovesciata per essere trovati letteralmente: \ ^ $ . | ? * + ( ) [ { (e ] } in alcune posizioni).
.Qualsiasi carattereUn singolo carattere qualsiasi tranne un'interruzione di riga. Aggiungi il flag s (dotAll) per includere le interruzioni di riga.
/h.t/g
su “hat hot h t hit h↵t”
trova “hat” “hot” “h t” “hit”- Python re: Esclude solo \n; JavaScript esclude anche \r, \u2028 e \u2029.
- Go RE2: Esclude solo \n.
\. \$ \(Escape di un metacarattereUna barra rovesciata rende letterale il carattere speciale successivo: \. è un punto vero, \$ un simbolo del dollaro.
/\$\d+\.\d{2}/g
su “Total $45.00, tax $3.15, tip 5”
trova “$45.00” “$3.15”\t \n \rTabulazione, nuova riga, ritorno a capoCaratteri di controllo per nome. I fine riga di Windows sono \r\n; \r?\n corrisponde a entrambi gli stili.
/\w+\t\w+/g
su “name⇥age↵ana⇥31”
trova “name⇥age” “ana⇥31”\xhhCarattere per codice esadecimaleEsattamente due cifre esadecimali: \x41 è A, \x20 uno spazio.
/\x41/g
su “A b A”
trova “A” “A”\uhhhhCarattere per unità di codice UnicodeQuattro cifre esadecimali per un carattere del Basic Multilingual Plane: \u00e9 è é.
/\u00e9/g
su “café résumé”
trova “é” “é” “é”- PCRE / PHP: Usa \x{e9}.
- Go RE2: Usa \x{e9}.
\u{1F600}Qualsiasi code point (anche astrale)Code point tra graffe, necessario per le emoji e gli altri caratteri sopra U+FFFF. JavaScript richiede il flag u o v.
/\u{1F600}/gu
su “Hi 😀 there 😀”
trova “😀” “😀”- PCRE / PHP: Scrivi \x{1F600} (PHP richiede il modificatore u).
- Python re: Scrivi \U0001F600 (otto cifre esadecimali).
- Go RE2: Scrivi \x{1F600}.
- Java: Scrivi \x{1F600}.
- .NET: Solo \uhhhh; un'emoji sono due unità di codice UTF-16, es. \uD83D\uDE00.
Classi di caratteri
Una classe corrisponde esattamente a un carattere di un insieme. Dentro [ ] quasi tutti i metacaratteri perdono il loro significato; serve attenzione solo con ] \ ^ e -.
[abc]Uno qualsiasi traUn carattere dell'elenco.
/gr[ae]y/g
su “gray grey groy”
trova “gray” “grey”[^abc]Nessuno traUn carattere che non è nell'elenco (un ^ in qualsiasi posizione tranne la prima è letterale). Corrisponde anche alle interruzioni di riga.
/[^aeiou\s]/g
su “regex”
trova “r” “g” “x”[a-z]IntervalloCaratteri compresi tra due code point. Combina gli intervalli: [A-Fa-f0-9] è una cifra esadecimale. Un - in prima o ultima posizione è letterale.
/[A-Fa-f0-9]+/g
su “x: 3fA9 zz”
trova “3fA9”\d \DCifra / non cifra\d è una cifra, \D qualsiasi altra cosa.
/\d+/g
su “Order 66, room 101”
trova “66” “101”- Python re: Nei pattern str \d corrisponde a qualsiasi cifra Unicode (es. ٣); usa re.ASCII per solo 0-9.
- .NET: Corrisponde a qualsiasi cifra Unicode, a meno che non sia impostato RegexOptions.ECMAScript.
\w \WCarattere di parola / non di parolaLettere, cifre e trattino basso. In JavaScript e Go significa solo ASCII: \w non corrisponde a é.
/\w+/g
su “snake_case and kebab-case”
trova “snake_case” “and” “kebab” “case”- PCRE / PHP: ASCII, a meno di PCRE2_UCP (PHP: modificatore u più (*UCP)).
- Python re: Lettere e cifre Unicode per impostazione predefinita nei pattern str.
- Java: ASCII, a meno che non sia attivo il flag U (UNICODE_CHARACTER_CLASS).
- .NET: Lettere, cifre e punteggiatura di connessione Unicode.
\s \SSpazio vuoto / non spazio vuotoSpazio, tabulazione, interruzioni di riga e (nella maggior parte dei motori) altri spazi Unicode.
/\s+/g
su “a b⇥c”
trova “ ” “⇥”- Go RE2: Solo spazi ASCII: \t \n \f \r e lo spazio.
[[:alpha:]]Classe POSIX tra parentesiClassi con nome come [:alpha:], [:digit:], [:space:], [:punct:], usate dentro le parentesi quadre.
[[:alpha:]]+- JavaScript: Usa [A-Za-z] o \p{L} con il flag u.
- Java: Usa \p{Alpha}, \p{Digit}, \p{Punct}.
[\p{L}--[a-z]]Sottrazione / intersezione di classiOperazioni sugli insiemi dentro una classe. JavaScript richiede il flag v (ES2024): -- sottrae, && interseca.
/[\p{L}--[a-z]]+/gv
su “abcÉtéXYZ”
trova “É” “éXYZ”- PCRE / PHP: Solo PCRE2 10.45+, con la sintassi di classe estesa (?[ … ]).
- Java: Intersezione [a-z&&[^aeiou]]; la sottrazione si scrive come intersezione con una negazione.
- .NET: Sottrazione [a-z-[aeiou]]; nessuna intersezione.
Ancore e confini
Le ancore corrispondono a una posizione, non a un carattere, quindi non consumano mai testo.
^ $Inizio / fine della stringa (o della riga con m)Senza il flag m, ^ e $ sono l'inizio e la fine dell'intero input; con il flag, di ogni riga.
/^\w+/gm
su “first line↵second line”
trova “first” “second”- PCRE / PHP: $ corrisponde anche prima di un \n finale.
- Python re: $ corrisponde anche prima di un \n finale.
- Java: $ corrisponde anche prima di un terminatore di riga finale.
- .NET: $ corrisponde anche prima di un \n finale.
\bConfine di parolaTra un carattere di parola e uno non di parola (o il bordo dell'input). Usalo per trovare parole intere.
/\bcat\b/g
su “cat concat cats cat.”
trova “cat” “cat”- JavaScript: Solo caratteri di parola ASCII, anche con il flag u.
- Go RE2: Solo caratteri di parola ASCII.
\BNon un confine di parolaAll'interno di una parola, es. "cat" solo quando fa parte di una parola più lunga.
/\Bcat/g
su “concat cat bobcat”
trova “cat” “cat”\A \z \ZInizio / fine assolutiInizio e fine dell'input indipendentemente dalla modalità multiriga. \Z ammette anche un a capo finale (tranne in Python, dove è un sinonimo di \z).
\A\d+\z- JavaScript: Usa ^ e $ senza il flag m.
- Python re: \A e \z (3.14+); \Z significa fine assoluta, come \z altrove.
- Go RE2: \A e \z; niente \Z.
\GFine della corrispondenza precedentePosizione in cui è terminata l'ultima corrispondenza; usata per trovare sequenze contigue.
\G\d- JavaScript: Niente \G; il flag y (sticky) offre lo stesso comportamento “inizia esattamente qui”.
Quantificatori: greedy, lazy, possessivi
Un quantificatore ripete l'elemento che lo precede. Greedy (predefinito) prende il più possibile e poi arretra; lazy (aggiungi ?) prende il meno possibile; possessivo (aggiungi +) non arretra mai.
*Zero o piùRipete da 0 a un numero illimitato di volte.
/ba*/g
su “b ba baaa”
trova “b” “ba” “baaa”+Uno o piùRipete da 1 a un numero illimitato di volte.
/lo+l/g
su “lol loool ll”
trova “lol” “loool”?FacoltativoZero o una volta.
/colou?r/g
su “color colour colouur”
trova “color” “colour”{n}Esattamente nEsattamente n ripetizioni.
/\d{3}/g
su “12 345 6789”
trova “345” “678”{n,}n o piùAlmeno n ripetizioni.
/\d{2,}/g
su “1 22 333”
trova “22” “333”{n,m}Tra n e mDa n a m ripetizioni, il più possibile.
/\d{2,3}/g
su “1 22 4444”
trova “22” “444”- Go RE2: I conteggi sopra 1000 vengono rifiutati.
{,m}Fino a mDa zero a m ripetizioni. Solo alcuni motori lo accettano; altrove è il testo letterale "{,m}" o un errore. {0,m} funziona ovunque.
\d{,3}- JavaScript: Testo letterale senza u, errore di sintassi con u; scrivi {0,3}.
- PCRE / PHP: Solo PCRE2 10.43+.
- Go RE2: Scrivi {0,3}.
- Java: Scrivi {0,3}.
- .NET: Trattato come testo letterale; scrivi {0,3}.
.* .+Greedy (predefinito)Prende la corrispondenza più lunga possibile, poi restituisce caratteri finché il resto non combacia. Qui inghiotte entrambi i tag.
/<.+>/g
su “<b>bold</b>”
trova “<b>bold</b>”*? +? ?? {n,m}?Lazy (non greedy)Prende la corrispondenza più breve possibile. Di solito è la soluzione quando un pattern “trova troppo”.
/<.+?>/g
su “<b>bold</b>”
trova “<b>” “</b>”- Go RE2: Disponibile anche come flag U, che scambia greedy e lazy.
*+ ++ ?+PossessivoGreedy senza backtracking: una volta trovati, i caratteri non vengono mai restituiti. Fallisce più in fretta ed è una difesa contro il backtracking catastrofico.
"[^"]*+"- JavaScript: Niente quantificatori possessivi né gruppi atomici; emulali con (?=(…))\1.
- Python re: Python 3.11+.
- Go RE2: Non serve: RE2 non fa mai backtracking.
- .NET: Usa un gruppo atomico (?>…).
Gruppi e backreference
Le parentesi raggruppano elementi per quantificatori e alternative e (se non marcate come non catturanti) salvano ciò che hanno trovato.
( … )Gruppo di catturaRaggruppa e cattura; numerati da 1 in base alla parentesi di apertura.
/(\d{3})-(\d{4})/g
su “Call 555-0199 or 555-0123”
trova “555-0199” “555-0123”(?: … )Gruppo non catturanteRaggruppa senza salvare, così i numeri dei gruppi restano stabili e la ricerca costa un po' meno.
/(?:ab)+/g
su “ababab ab a”
trova “ababab” “ab”(?<name> … )Gruppo con nomeCattura sotto un nome che puoi rileggere (match.groups.name in JavaScript).
/(?<year>\d{4})-(?<month>\d{2})/g
su “Released 2026-10”
trova “2026-10”- PCRE / PHP: Anche (?'name'…) e (?P<name>…).
- Python re: Solo (?P<name>…).
- Go RE2: (?P<name>…); (?<name>…) accettato anche da Go 1.22.
- .NET: Anche (?'name'…).
\1Backreference per numeroCorrisponde allo stesso testo catturato in precedenza da un gruppo.
/(\w)\1/g
su “bookkeeper”
trova “oo” “kk” “ee”- Go RE2: RE2 non ha backreference (romperebbero la sua garanzia di tempo lineare).
\k<name>Backreference per nomeCome \1 ma per nome. L'esempio trova testo tra virgolette corrispondenti.
/(?<q>['"]).*?\k<q>/g
su “say "hi" or 'yo'”
trova “"hi"” “'yo'”- PCRE / PHP: Anche \k{name}, \g{name} e (?P=name).
- Python re: Scrivi (?P=name).
a|bAlternativa (o)L'uno o l'altro lato. Le alternative vengono provate da sinistra a destra, quindi metti prima le più lunghe quando una è prefisso di un'altra.
/cat|dog/g
su “hotdog catalog”
trova “dog” “cat”(?> … )Gruppo atomicoUna volta che il gruppo ha trovato una corrispondenza, il motore non vi rientra con il backtracking.
(?>a|ab)c- Python re: Python 3.11+.
- Go RE2: Non serve: RE2 non fa mai backtracking.
(?i) (?i: … )Flag in lineaAttivano o disattivano i flag dentro il pattern. (?i) si applica al resto del pattern; (?i:…) solo al gruppo; (?-i:…) disattiva un flag.
/(?i:hello) world/g
su “HELLO world HELLO WORLD”
trova “HELLO world”- JavaScript: Solo la forma limitata (?i:…) / (?-i:…), per i, m e s (ES2025). (?i) all'inizio è un errore di sintassi.
- Python re: Il (?i) globale deve stare proprio all'inizio del pattern (altrove è un errore dalla 3.11); (?i:…) funziona ovunque.
(?(1)yes|no)CondizionaleCorrisponde a "yes" se il gruppo 1 ha partecipato, altrimenti a "no".
(<)?\w+(?(1)>)(?R) (?1)Ricorsione / subroutineRientra nell'intero pattern o in un gruppo, per strutture annidate come parentesi bilanciate.
\((?:[^()]|(?R))*\)- Python re: Disponibile nel modulo di terze parti regex.
- .NET: Nessuna ricorsione; i balancing group (?<open-close>…) gestiscono l'annidamento.
(?# … )Commento in lineaIgnorato dal motore. Per commenti più lunghi usa il flag x (esteso).
\d{3}(?#area code)Lookahead e lookbehind
I lookaround controllano cosa c'è accanto alla posizione corrente senza includerlo nella corrispondenza. Hanno larghezza zero, come le ancore.
(?= … )Lookahead positivoSeguito da … (non incluso nella corrispondenza).
/\d+(?=px)/g
su “10px 20em 30px”
trova “10” “30”- Go RE2: RE2 non ha alcun tipo di lookaround.
(?! … )Lookahead negativoNon seguito da …. Il \d all'interno impedisce al motore di restituire cifre per far passare il controllo.
/\d+(?!px|\d)/g
su “10px 20em”
trova “20”(?<= … )Lookbehind positivoPreceduto da … (non incluso nella corrispondenza).
/(?<=\$)\d+(?:\.\d\d)?/g
su “Cost: $42.50 or 42”
trova “42.50”- JavaScript: Qualsiasi lunghezza (ES2018).
- PCRE / PHP: Ogni alternativa deve avere lunghezza limitata; lunghezza variabile (max 255 per impostazione predefinita) da PCRE2 10.43.
- Python re: Solo larghezza fissa: (?<=ab|cd) va bene, (?<=a+) è un errore.
- Java: Solo lunghezza limitata: niente * o + all'interno.
- .NET: Qualsiasi lunghezza.
(?<! … )Lookbehind negativoNon preceduto da ….
/(?<!\$)\b\d+\b/g
su “$30 and 45”
trova “45”- PCRE / PHP: Stesse regole di lunghezza del lookbehind positivo.
- Python re: Solo larghezza fissa.
- Java: Solo lunghezza limitata.
\KReimposta l'inizio della corrispondenzaEsclude dal risultato tutto ciò che è stato trovato finora; un lookbehind senza limiti di lunghezza.
price: \K\d+- JavaScript: Usa (?<=…) o un gruppo di cattura.
Flag (modificatori)
JavaScript scrive i flag dopo la barra di chiusura (/x/gi). Gli altri linguaggi passano costanti (re.I, Pattern.CASE_INSENSITIVE, RegexOptions.IgnoreCase) o usano (?i) in linea.
gGlobale (tutte le corrispondenze)Trova ogni corrispondenza invece di fermarsi alla prima. Richiesto da matchAll e replaceAll.
/o/g
su “foo boo”
trova “o” “o” “o” “o”- PCRE / PHP: Nessun flag: usa preg_match_all() / preg_replace().
- Python re: Nessun flag: usa re.findall(), re.finditer(), re.sub().
- Go RE2: Nessun flag: usa i metodi FindAll….
- Java: Nessun flag: cicla con matcher.find().
- .NET: Nessun flag: usa Regex.Matches().
iIgnora maiuscole/minuscoleRicerca senza distinzione tra maiuscole e minuscole.
/hello/gi
su “Hello HELLO hello”
trova “Hello” “HELLO” “hello”- Python re: re.I / re.IGNORECASE o (?i).
- Java: CASE_INSENSITIVE (ASCII a meno di UNICODE_CASE) o (?i).
- .NET: RegexOptions.IgnoreCase o (?i).
mMultiriga^ e $ corrispondono a inizio e fine di ogni riga, non solo agli estremi dell'input.
/^-\s.+$/gm
su “- one↵- two↵three”
trova “- one” “- two”- Python re: re.M / re.MULTILINE.
- .NET: RegexOptions.Multiline.
sIl punto include l'a capoFa sì che . corrisponda anche alle interruzioni di riga. Senza, [\s\S] è il “qualsiasi cosa” portabile.
/<p>.*?</p>/gs
su “<p>a↵b</p>”
trova “<p>a↵b</p>”- Python re: re.S / re.DOTALL.
- Java: Pattern.DOTALL.
- .NET: Si chiama RegexOptions.Singleline.
xEsteso (spaziatura libera)Gli spazi nel pattern vengono ignorati e # inizia un commento, così i pattern lunghi si possono distribuire su più righe.
(?x) \d{3} - \d{4} # local number- Python re: re.X / re.VERBOSE.
- Java: Pattern.COMMENTS.
- .NET: RegexOptions.IgnorePatternWhitespace.
uUnicodeTratta l'input come code point (così . corrisponde a un'intera emoji), abilita \p{…} e \u{…} e rende errori gli escape non validi.
/^.$/gu
su “😀”
trova “😀”- PCRE / PHP: Modificatore u di PHP (modalità UTF-8); aggiungi (*UCP) per \w e \d Unicode.
- Python re: Nessun flag necessario: i pattern str sono Unicode; re.ASCII lo disattiva.
- Go RE2: Nessun flag: Go lavora sempre su code point UTF-8.
- Java: UNICODE_CASE e UNICODE_CHARACTER_CLASS (U).
- .NET: Nessun flag: sempre unità di codice UTF-16 (un'emoji ne occupa due).
vInsiemi UnicodeEvoluzione ES2024 di u: operazioni sugli insiemi nelle classi (--, &&), classi annidate e proprietà di stringa come \p{RGI_Emoji}. Non si può combinare con u.
/[\p{L}&&\p{ASCII}]+/gv
su “Ünïcode text”
trova “n” “code” “text”yStickyOgni corrispondenza deve iniziare esattamente dove è finita la precedente (lastIndex). Utile per i tokenizer.
/\d/gy
su “12a3”
trova “1” “2”- PCRE / PHP: Usa \G.
- Python re: Usa pattern.match(text, pos).
- Java: Usa \G o matcher.lookingAt().
- .NET: Usa \G.
dIndici delle corrispondenzeAggiunge match.indices con inizio e fine di ogni gruppo di cattura (ES2022).
/(?<y>\d{4})/d- PCRE / PHP: Offset sempre disponibili (PREG_OFFSET_CAPTURE).
- Python re: Sempre disponibile: m.span(n).
- Go RE2: Sempre disponibile: FindStringSubmatchIndex.
- Java: Sempre disponibile: matcher.start(n) / end(n).
- .NET: Sempre disponibile: Group.Index / Length.
Proprietà Unicode \p{…}
Gli escape di proprietà trovano i caratteri per categoria o sistema di scrittura Unicode: è l'unico modo affidabile per trovare “qualsiasi lettera” in tutte le lingue. In JavaScript richiedono il flag u o v.
\p{L}Qualsiasi letteraLettere di ogni sistema di scrittura: é, ß, 東, д.
/\p{L}+/gu
su “naïve café 東京 123”
trova “naïve” “café” “東京”- PCRE / PHP: PHP richiede il modificatore u per l'input UTF-8.
- Python re: Usa il modulo di terze parti regex, oppure [^\W\d_] per le “lettere”.
\p{Lu} \p{Ll}Lettera maiuscola / minuscolaCategorie generali: Lu maiuscola, Ll minuscola, N numero, P punteggiatura, S simbolo, Z separatore.
/\p{Lu}/gu
su “Élan Vital”
trova “É” “V”\P{…}Non nella proprietàLa P maiuscola nega: \P{L} è tutto ciò che non è una lettera.
/\P{L}+/gu
su “abc-123”
trova “-123”\pLForma abbreviata a una letteraCategorie di una sola lettera senza graffe.
\pL+- JavaScript: Le graffe sono obbligatorie: \p{L}.
- .NET: Le graffe sono obbligatorie: \p{L}.
\p{Script=Greek}Sistema di scritturaCaratteri di un sistema di scrittura. sc= è la forma breve; Script_Extensions (scx=) include anche i caratteri condivisi tra più sistemi.
/\p{Script=Greek}+/gu
su “alpha α, beta β”
trova “α” “β”- PCRE / PHP: \p{Greek}, \p{sc:Greek} o \p{scx:Greek}.
- Go RE2: \p{Greek}.
- Java: Scrivi \p{script=Greek}, \p{sc=Greek} o \p{IsGreek}.
- .NET: Solo blocchi con nome come \p{IsGreek} (un intervallo di codici, non il sistema di scrittura).
\p{sc=Han}Ideogrammi cinesi / kanji giapponesiIdeogrammi Han. Per i kana giapponesi aggiungi \p{sc=Hiragana} e \p{sc=Katakana}.
/\p{sc=Han}+/gu
su “Tokyo 東京 2026 中文”
trova “東京” “中文”- PCRE / PHP: \p{Han}.
- Python re: Usa un intervallo come [\u4e00-\u9fff] (copre solo il blocco principale).
- Go RE2: \p{Han}.
- Java: Anche \p{IsHan}.
- .NET: Solo blocchi, es. \p{IsCJKUnifiedIdeographs}.
\p{RGI_Emoji}Emoji (sequenze intere)Con il flag v trova emoji complete, comprese tonalità della pelle e sequenze di famiglia. Con u, \p{Extended_Pictographic} trova solo singoli pittogrammi.
/\p{RGI_Emoji}/gv
su “Go 👍🏽 team 👨👩👧!”
trova “👍🏽” “👨👩👧”- PCRE / PHP: Singoli code point tramite proprietà booleane nelle versioni recenti di PCRE2 (10.40+); nessuna proprietà per le sequenze.
- Java: \p{IsEmoji} trova singoli code point (Java 21+).
\XCluster di grafemiUn carattere così come lo percepisce l'utente, es. e + accento combinante, o un'emoji di bandiera.
\X- JavaScript: Usa Intl.Segmenter per dividere in grafemi.
- Python re: Disponibile nel modulo regex.
Sintassi di sostituzione
Cosa scrivere nella stringa di sostituzione. È qui che i linguaggi differiscono di più, quindi la colonna del tuo linguaggio conta più dell'esempio JavaScript.
$&Corrispondenza interaInserisce l'intero testo trovato.
/\d+/g
su “3 apples, 12 pears”
sostituisci con “[$&]” → “[3] apples, [12] pears”- PCRE / PHP: $0 o \0 in preg_replace.
- Python re: \g<0>.
- Go RE2: ${0} o $0 (Expand / ReplaceAllString).
- Java: $0.
- .NET: Anche $0.
$1Gruppo numeratoInserisce ciò che ha catturato il gruppo 1. Scambiare due parole:
/(\w+)\s(\w+)/g
su “hello world”
sostituisci con “$2 $1” → “world hello”- PCRE / PHP: Anche \1 e ${1}.
- Python re: \1 o \g<1> (usa una stringa raw r"\1").
- Go RE2: Usa ${1}x quando segue una lettera o una cifra, altrimenti Go legge $1x come un gruppo chiamato "1x".
$<name>Gruppo con nomeInserisce un gruppo con nome. Riformattare una data ISO come giorno/mese/anno:
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g
su “2026-10-18”
sostituisci con “$<d>/$<m>/$<y>” → “18/10/2026”- PCRE / PHP: preg_replace non ha riferimenti per nome; usa il numero del gruppo o preg_replace_callback().
- Python re: \g<name>.
- Go RE2: ${name} (o $name).
- Java: ${name}.
- .NET: ${name}.
$$Simbolo del dollaro letteraleEsegue l'escape di $ nella sostituzione.
/(\d+)/g
su “Price: 20”
sostituisci con “$$$1” → “Price: $20”- PCRE / PHP: Un $ non seguito da una cifra o da { è già letterale; scrivi ${1} dopo di esso.
- Python re: $ non è speciale; esegui l'escape delle barre rovesciate come \\.
- Java: \$ (Matcher.quoteReplacement() esegue l'escape di un'intera stringa).
$` $'Testo prima / dopo la corrispondenzaInserisce l'input che precede o segue la corrispondenza. Serve di rado, ma a volte è comodo.
/=/
su “key=value”
sostituisci con “ is set ($') and was ($`) ” → “key is set (value) and was (key) value”Ricette comuni (con avvertenze oneste)
I pattern più cercati, scritti per essere leggibili e al riparo dal backtracking catastrofico. Ognuno dice cosa non fa.
Email (practical)Trova stringhe simili a emailParte locale, @ e un dominio con almeno un punto.
/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g
su “Write to ana.lee+news@example.co.uk or bob@test.dev.”
trova “ana.lee+news@example.co.uk” “bob@test.dev”Attenzione: Rifiuta indirizzi validi ma rari (parti locali tra virgolette, domini non ASCII) e accetta alcuni indirizzi non validi (a..b@x.y). Nessuna regex può dirti se una casella esiste: invia un'email di conferma.
URLTrova link http(s) in un testoSi ferma a spazi, virgolette e parentesi angolari, ed esclude la punteggiatura finale come un punto o una virgola.
/https?://[^\s<>"]*[^\s<>".,;:!?)]/g
su “See https://example.com/a?b=1, or (http://test.dev/x).”
trova “https://example.com/a?b=1” “http://test.dev/x”Attenzione: Va bene per trasformare il testo in link, non per la convalida. Per controllare un URL usa il parser di URL del tuo linguaggio (new URL() in JavaScript) e verificane protocollo e host.
IPv4 addressQuattro ottetti 0–255Ogni ottetto limitato a 0–255 senza zeri iniziali.
/\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b/g
su “10.0.0.1 256.1.1.1 192.168.1.254”
trova “10.0.0.1” “192.168.1.254”Attenzione: Non gestisce IPv6, suffissi CIDR o porte. Per la convalida usa un parser di IP (Python ipaddress, Go net/netip, Node net.isIP).
Date YYYY-MM-DDData di calendario ISO 8601Mese 01–12 e giorno 01–31.
/\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g
su “2026-10-18, 2026-13-01, 2026-02-31”
trova “2026-10-18” “2026-02-31”Attenzione: Solo la forma: 2026-02-31 passa. Analizza la data con una libreria per scartare i giorni impossibili.
Date MM/DD/YYYYData in formato USAMese e giorno a una o due cifre, anno a quattro cifre.
/\b(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[12]\d|3[01])/\d{4}\b/g
su “Due 10/18/2026 or 1/5/2027, not 13/01/2026”
trova “10/18/2026” “1/5/2027”Attenzione: 01/02/2026 è il 2 gennaio negli USA e il 1° febbraio quasi ovunque altrove; una regex non può sapere quale si intendeva.
Phone (North America)(416) 555-0199 e variantiDieci cifre con parentesi, spazi, punti o trattini facoltativi.
/\(?\b\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g
su “(416) 555-0199, 416.555.0199, 4165550199”
trova “(416) 555-0199” “416.555.0199” “4165550199”Attenzione: Solo numeri nordamericani. Per i numeri internazionali usa una libreria come libphonenumber; memorizza i numeri in formato E.164 (riga successiva).
Phone (E.164)Formato internazionale +CC…Un segno più, un prefisso internazionale che non inizia con 0, fino a 15 cifre in totale.
/^\+[1-9]\d{1,14}$/gm
su “+14165550199↵+447911123456↵0044791112”
trova “+14165550199” “+447911123456”Attenzione: Controlla la forma E.164, non se il numero è assegnato o ha la lunghezza giusta per il suo paese.
Hex colour#rgb, #rgba, #rrggbb, #rrggbbaaLe quattro lunghezze accettate da CSS.
/#(?:[\da-fA-F]{8}|[\da-fA-F]{6}|[\da-fA-F]{3,4})\b/g
su “#fff #244b3f #12345 #ff000080 #1234567”
trova “#fff” “#244b3f” “#ff000080”Attenzione: Trova corrispondenze anche dentro testo più lungo, come URL con #frammenti; ancoralo con ^…$ per convalidare un singolo valore.
URL slugparole-minuscole-con-trattiniLettere minuscole e cifre separate da singoli trattini.
/^[a-z0-9]+(?:-[a-z0-9]+)*$/gm
su “my-post-2026↵My Post↵-bad-↵good”
trova “my-post-2026” “good”Attenzione: Solo ASCII. Per creare slug dai titoli, usa il generatore di slug URL invece di una regex.
Trim whitespaceSpazi iniziali e finaliSostituisci con una stringa vuota. Senza il flag m, ^ e $ sono gli estremi dell'intero testo.
/^\s+|\s+$/g
su “ padded text ”
sostituisci con “” → “padded text”Attenzione: Ogni linguaggio moderno ha una funzione trim() integrata più veloce e chiara; usa la regex solo dove non puoi eseguire codice (editor, file di configurazione).
Collapse spacesSequenze di spazi ridotte a unoSostituisci due o più spazi o tabulazioni con un solo spazio.
/[ \t]{2,}/g
su “too many ⇥ spaces”
sostituisci con “ ” → “too many spaces”Duplicate wordsil il, è èUna parola seguita da se stessa. Con i, viene trovato anche “Il il”.
/\b(\w+)\s+\1\b/gi
su “This is is a test test of The the editor”
trova “is is” “test test” “The the”Attenzione: Richiede le backreference, quindi non funziona in Go. In inglese “had had” e “that that” a volte sono corretti.
Password rulesMinuscola, maiuscola, cifra, 12+ caratteriOgni lookahead controlla una regola dall'inizio; .{12,} imposta la lunghezza.
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/gm
su “short1A↵alllowercase123↵GoodPassword42”
trova “GoodPassword42”Attenzione: NIST SP 800-63B sconsiglia le regole di composizione: richiedi una lunghezza minima e confronta invece con gli elenchi di password violate.
UUID8-4-4-4-12 esadecimaleVersioni 1–8 con i bit di variante di RFC 9562.
/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi
su “id 3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b and 00000000-0000-0000-0000-000000000000”
trova “3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b”Attenzione: Rifiuta il nil UUID (tutti zeri) e il max UUID (tutte f), che sono valori speciali validi.
Un riferimento statico: ricerca e filtri avvengono nel tuo browser, e i link Provalo aprono il nostro tester regex che funziona nel browser. Sfoglia tutti gli strumenti gratuiti.
Hai trovato un problema o qualcosa che potrebbe andare meglio? Leggiamo ogni messaggio e sistemiamo le cose in fretta.
Questa guida rapida alle regex elenca tutti i token delle espressioni regolari che probabilmente ti serviranno, da \d e \b fino a lookbehind, quantificatori possessivi e \p{Script=Greek}, ognuno con una breve spiegazione e un esempio che mostra esattamente cosa trova. Ogni esempio ha un link Provalo che apre il nostro tester regex con pattern, flag e testo di prova già inseriti, così puoi modificarlo e vedere le corrispondenze cambiare.
Le regex sembrano uguali ovunque, ma non lo sono. Il lookbehind è illimitato in JavaScript e .NET, a larghezza fissa in Python, limitato in Java e PCRE e assente in Go. Python scrive i gruppi con nome (?P<name>…), PHP non può usare i nomi in una sostituzione e solo alcuni motori conoscono \A, \K o (?R). Il selettore del dialetto mostra il supporto di ogni token in JavaScript, PCRE/PHP, Python, Go, Java e .NET, con la sintassi alternativa dove esiste. Gli esempi vengono eseguiti in JavaScript; per gli altri linguaggi leggi le note e fai una prova in quel linguaggio prima di andare in produzione.
Come si usa
- Cerca un token (\b, lookahead) o un'attività (email, trim, parole duplicate), oppure passa a una sezione con i chip in alto.
- Scegli il tuo linguaggio nella barra dei dialetti. I token che non supporta vengono attenuati e la nota sotto ogni voce indica la sintassi che usa al loro posto.
- Fai clic su Provalo nel tester regex per eseguire l'esempio dal vivo, poi modifica lì il pattern o il testo.
- Usa il # accanto a una voce per creare un link diretto, oppure Stampa / Salva in PDF per una copia compatta su due colonne.
Domande frequenti
Che differenza c'è tra quantificatori greedy e lazy?
Un quantificatore greedy (*, +, {n,m}) prende quanti più caratteri possibile e poi ne restituisce alcuni se il resto del pattern fallisce; uno lazy (*?, +?, {n,m}?) ne prende il meno possibile. Su <b>bold</b>, <.+> trova l'intera stringa mentre <.+?> trova <b> e </b> separatamente. I quantificatori possessivi (*+, ++) sono greedy e non restituiscono mai caratteri; JavaScript, Go e .NET non li hanno.
Quali linguaggi supportano il lookbehind?
JavaScript (da ES2018) e .NET ammettono lookbehind di qualsiasi lunghezza. Java richiede una lunghezza massima limitata, quindi niente * o + all'interno. Il modulo re di Python accetta solo lookbehind a larghezza fissa. PCRE2 richiedeva che ogni alternativa avesse lunghezza fissa fino alla 10.43, che ha aggiunto il lookbehind a lunghezza variabile fino a un limite (255 caratteri per impostazione predefinita). Il motore RE2 di Go non ha né lookahead né lookbehind.
Come trovo qualsiasi lettera, comprese quelle accentate e non latine?
Usa la proprietà Unicode \p{L}. In JavaScript richiede il flag u o v (/\p{L}+/u); PCRE, Go, Java e .NET la supportano direttamente. [a-zA-Z] non trova é, ß né alcun alfabeto non latino, e \w è solo ASCII in JavaScript e Go. Il modulo re integrato di Python non ha \p{…}: usa il modulo esterno regex oppure [^\W\d_], che in Python 3 trova le lettere Unicode.
Come uso un gruppo catturato nella sostituzione?
Dipende dal linguaggio: $1 in JavaScript, Java, .NET, Go e PHP; \1 o \g<1> in Python. I gruppi con nome sono $<name> in JavaScript, ${name} in Java, .NET e Go, e \g<name> in Python; preg_replace di PHP non ha una forma con nome, quindi usa il numero. L'intera corrispondenza è $& in JavaScript e .NET, $0 in Java e PHP e \g<0> in Python.
Perché la mia regex funziona in JavaScript ma non in Python (o viceversa)?
I soliti colpevoli: i gruppi con nome ((?<name>) in JavaScript, (?P<name>) in Python), le proprietà \p{…} (sì in JavaScript, no in Python re), la lunghezza del lookbehind (qualsiasi in JavaScript, fissa in Python), i flag inline ((?i) all'inizio funziona in Python ma è un errore in JavaScript, che ha solo la forma con ambito (?i:…)) e \d o \w che in Python trovano cifre e lettere Unicode ma in JavaScript solo ASCII. Ricorda anche l'escaping delle stringhe in Python: scrivi i pattern come raw string, r"\d+".
È sicuro validare gli indirizzi email con una regex?
Solo come controllo della forma. Un pattern pratico come [\w.+-]+@[\w-]+(?:\.[\w-]+)+ intercetta gli errori di battitura, ma rifiuta alcuni indirizzi validi (parti locali tra virgolette, domini internazionalizzati) e ne accetta alcuni non validi. Nessun pattern può dirti se una casella esiste, quindi controlla la forma in modo permissivo e poi invia un'email di conferma.
Scrivere pattern che funzionano in più linguaggi
Se un pattern deve girare su più motori (una regola di validazione condivisa, un file di configurazione letto da servizi in linguaggi diversi), resta nel sottoinsieme comune. Questi elementi si comportano allo stesso modo in tutti e sei i motori di questa pagina:
• Caratteri letterali, escape come \. e \$, e le classi [abc], [^abc] e [a-z].
• \d, \s e \w, purché l'input sia ASCII (Python e .NET trovano anche cifre e lettere Unicode).
• ^ e $, \b, alternanza, gruppi di cattura e non di cattura.
• Quantificatori greedy e lazy: *, +, ?, {n}, {n,m} e le loro forme con ?.
Evita lookaround (Go non ne ha), backreference (Go), quantificatori possessivi e gruppi atomici (a JavaScript, Go e .NET manca uno dei due o entrambi), gruppi con nome (la sintassi di Python è diversa) e \p{…} (manca in Python re). Quando ti serve uno di questi, tieni una copia del pattern per ogni linguaggio e testale tutte.
Evitare il backtracking catastrofico
I motori con backtracking (JavaScript, PCRE, Python, Java, .NET) possono impiegare un tempo esponenziale su pattern in cui un gruppo quantificato può trovare lo stesso testo in molti modi, come (a+)+$ o (\w|\d)*x. Su un input lungo che quasi corrisponde, il motore prova ogni suddivisione prima di fallire, e un server web può bloccarsi su una sola richiesta. È il problema del denial of service tramite espressioni regolari (ReDoS).
Le soluzioni sono meccaniche: evita di annidare quantificatori sugli stessi caratteri; rendi le alternative mutuamente esclusive; preferisci una classe negata come [^"]* a .*? quando conosci il delimitatore; usa quantificatori possessivi o gruppi atomici dove il tuo motore li ha; e limita la lunghezza dell'input prima del confronto. .NET offre anche RegexOptions.NonBacktracking e un timeout di corrispondenza, PCRE ha limiti di corrispondenza configurabili e il motore RE2 di Go garantisce un tempo lineare non supportando le funzioni che richiedono backtracking.
Escaping delle regex dentro le stringhe
Nel codice reale, la maggior parte dei bug con le regex sono bug di escaping delle stringhe, non delle regex. Il backslash è speciale sia per il letterale stringa del linguaggio sia per il motore regex, quindi un pattern scritto come stringa normale richiede backslash doppi.
• JavaScript: un letterale /\d+/ richiede un backslash; new RegExp("\\d+") ne richiede due. String.raw`\d+` evita il raddoppio.
• Python: usa sempre le raw string, r"\d+"; altrimenti "\b" è un carattere backspace, non un confine di parola.
• Java e C#: "\\d+" nelle stringhe normali (anche i text block di Java elaborano gli escape); le stringhe verbatim di C#, @"\d+", mantengono i backslash come li scrivi.
• Go: le raw string tra backtick, `\d+`, sono la norma con regexp.MustCompile.
• PHP: i pattern includono i delimitatori, '/\d+/', e le stringhe tra apici singoli mantengono la maggior parte dei backslash come li scrivi.
Strumenti gratuiti correlati
- Tester regex — Prova un'espressione regolare su un testo di esempio con evidenziazione delle corrispondenze in tempo reale, gruppi di cattura e anteprima della sostituzione. Gratis, nel browser.
- Guida rapida Git — Comandi Git organizzati per ciò che vuoi fare: annullare l'ultimo commit, rinominare un branch, eliminare un branch remoto. I moderni switch/restore con gli equivalenti classici e badge di pericolo.
- Guida rapida Markdown — Ogni elemento Markdown con sorgente e anteprima, sintassi estesa (tabelle, elenchi di attività, note a piè di pagina, formule, Mermaid, avvisi), una tabella di compatibilità per 9 piattaforme e un'area di prova dal vivo.
- Generatore di espressioni cron — Crea una pianificazione cron con i menu a tendina o incollane una, leggila in parole semplici e vedi le prossime 10 esecuzioni nel tuo fuso orario e in UTC. Gratis, nel browser.
- Confronto testi (diff) — Confronta due versioni di un testo, di codice o di un file JSON e vedi esattamente quali righe, parole e caratteri sono cambiati.