Come usare il tester di regex
- Inserisci il tuo pattern senza le barre che lo racchiudono, per esempio
\d{3}-\d{4}. - Attiva i flag che ti servono (
g,i,m,s,u,y). - Incolla il testo di prova. Le corrispondenze vengono evidenziate in tempo reale e ogni gruppo di cattura viene elencato.
- Facoltativamente inserisci una stringa di sostituzione, usando
$1o$<name>per i gruppi, per vedere l'anteprima del risultato.
Il tester usa il motore regex JavaScript del tuo browser. I tuoi pattern e i dati di prova restano sul tuo dispositivo e non vengono caricati né memorizzati.
La sintassi delle regex JavaScript in breve
Le varianti delle espressioni regolari differiscono da un linguaggio all'altro. Questo strumento usa la variante JavaScript (ECMAScript), quindi i risultati corrispondono a ciò che fanno RegExp, String.prototype.match e replace nei browser e in Node.js. La maggior parte della sintassi vale anche per Python, PCRE e Java, ma dettagli come la sintassi dei gruppi con nome e il supporto del lookbehind variano.
Flag
| Flag | Nome | Effetto |
|---|---|---|
g | global | Trova tutte le corrispondenze invece di fermarsi dopo la prima. |
i | ignoreCase | Corrispondenza senza distinzione tra maiuscole e minuscole. |
m | multiline | ^ e $ corrispondono all'inizio e alla fine di ogni riga. |
s | dotAll | . corrisponde anche agli a capo. |
u | unicode | Tratta il pattern come punti di codice Unicode; abilita le sequenze di proprietà \p{...}. |
y | sticky | Corrisponde solo alla posizione indicata da lastIndex. |
Elementi di base
- Classi di caratteri:
[abc], intervalli[a-z], negazione[^0-9], abbreviazioni\d(cifra),\w(carattere di parola),\s(spazio) e le loro negazioni\D,\W,\S. Senza il flagu,\we\dcoprono solo l'ASCII. - Quantificatori:
*(0 o più),+(1 o più),?(0 o 1),{n},{n,},{n,m}. Aggiungi?per renderli pigri (lazy):.*?. - Gruppi:
(...)cattura,(?:...)raggruppa senza catturare,(?<year>\d{4})crea un gruppo con nome, e\1o\k<year>vi fa riferimento. - Ancore:
^,$e il confine di parola\b. - Lookaround:
(?=...)lookahead positivo,(?!...)lookahead negativo,(?<=...)lookbehind positivo,(?<!...)lookbehind negativo. Verificano il contesto senza consumare caratteri.
// Importi preceduti da un segno di dollaro, senza il segno
/(?<=\$)\d+(?:\.\d{2})?/g "Total: $42.50" → "42.50"
// Riformatta le date con i gruppi con nome
"2024-03-15".replace(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/, "$<d>.$<m>.$<y>")
// "15.03.2024"Pattern comuni
| Scopo | Pattern | Limiti |
|---|---|---|
| Email (semplice) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ | Solo un controllo di buon senso. La sintassi completa degli indirizzi è molto più complessa; conferma inviando un'email. |
| Indirizzo IPv4 | ^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$ | Rifiuta gli ottetti superiori a 255 e gli zeri iniziali. Non gestisce l'IPv6. |
| Data (YYYY-MM-DD) | ^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$ | Accetta date impossibili come 2023-02-31. Convalida con una libreria di date. |
| URL (http/https) | ^https?:\/\/[^\s/$.?#][^\s]*$ | Controllo approssimativo. Per un vero parsing usa il costruttore URL. |
Per gli indirizzi IP in particolare, il convertitore di indirizzi IP analizza e converte sia IPv4 sia IPv6.
Trappole
Backtracking catastrofico
Quantificatori annidati o sovrapposti possono indurre un motore con backtracking come quello di JavaScript a provare un numero esponenziale di percorsi quando una corrispondenza fallisce. Poche decine di caratteri possono bloccare una scheda del browser o, su un server, permettere un attacco denial-of-service (ReDoS):
/^(a+)+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!") // può bloccarsi
/^a+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!") // istantaneoEvita pattern come (a+)+, (a|a)* o (.*)*, mantieni le alternative mutuamente esclusive e sii specifico: [^"]* è più sicuro di .* dentro le virgolette.
Altre insidie
- Una regex con il flag
gricordalastIndex, quindi chiamare ripetutamentetest()sullo stesso oggetto alterna tratrueefalse. - Quando costruisci un pattern da una stringa, i backslash vanno raddoppiati:
new RegExp("\\d+"). - Dimenticare
^e$significa che un validatore accetta qualsiasi input che si limiti a contenere una corrispondenza.
Domande frequenti
Perché la mia regex funziona qui ma non in Python o PHP?
Le varianti differiscono. Python scrive i gruppi con nome come (?P<name>...) e supporta solo lookbehind a larghezza fissa; il PCRE di PHP racchiude i pattern tra delimitatori. Anche le regole di escape per i letterali stringa differiscono tra i linguaggi.
Che differenza c'è tra quantificatori greedy e lazy?
I quantificatori greedy (.*) corrispondono a quanto più possibile e poi arretrano; quelli lazy (.*?) corrispondono a quanto meno possibile. Su <b>x</b>, <.*> corrisponde all'intera stringa mentre <.*?> corrisponde solo a <b>.
JavaScript supporta il lookbehind?
Sì, da ES2018, e a differenza di molti motori consente un lookbehind a lunghezza variabile. Tutti i principali browser attuali lo supportano.
Come faccio a trovare un punto o una parentesi letterale?
Fai l'escape con un backslash: \., \[, \(. Dentro una classe di caratteri la maggior parte dei caratteri è letterale, quindi [.] corrisponde anch'esso a un punto.
Aggiornato