Foglio riepilogativo delle espressioni regolari: sintassi, flag e modelli comuni
Risposta rapida
Una regex combina caratteri letterali, metacaratteri (., \d, \w, \s), quantificatori (*, +, ?, {n,m}), ancore (^, $, \b) e gruppi ((...), [...]). Flag come g (globale), i (senza distinzione tra maiuscole e minuscole), m (multilinea) modificano il comportamento di corrispondenza. Testa i modelli in tempo reale con il nostro Regex Tester prima di incorporarli nel codice.
Introduzione
Le espressioni regolari (regex) descrivono modelli di testo utilizzando un linguaggio formale compatto. Sono supportati da tutti i linguaggi di programmazione, editor e strumenti di ricerca moderni. Questo cheat sheet è un riferimento per la sintassi definita da ECMAScript (utilizzata da JavaScript) oltre a modelli comuni che puoi copiare e adattare. Utilizza il nostro Regex Tester per provare qualsiasi modello rispetto al testo di esempio nel tuo browser.
Passo dopo passo
-
Classi di caratteri: corrispondono a un set di caratteri
[abc] corrisponde a, b o c. [^abc] corrisponde a qualsiasi cosa tranne a, b, c. [a-z] corrisponde a qualsiasi lettera minuscola. Classi predefinite: \d = [0-9], \D = non cifra, \w = [A-Za-z0-9_], \W = non parola, \s = spazio bianco, \S = non spazio bianco, . = qualsiasi carattere tranne il fine riga (usa il flag s per includere il fine riga).
-
Quantificatori: quante volte ripetere
* = 0 o più. + = 1 o più. ? = 0 o 1. {n} = esattamente n. {n,} = almeno n. {n,m} = tra n e m. Aggiungere ? per la corrispondenza pigra (ad esempio *? corrisponde al minor numero possibile). Greedy è l'impostazione predefinita e può causare un backtracking catastrofico sui modelli nidificati.
-
Ancore e confini: dove abbinare
^ corrisponde all'inizio della stringa (o della riga con il flag m). $ corrisponde alla fine. \b corrisponde al confine di una parola (tra \w e \W). \B corrisponde a un confine non di parola. Le ancore hanno larghezza zero: testano la posizione senza consumare caratteri.
-
Gruppi e alternanza
(abc) è un gruppo di cattura; utilizzare $ 1, $ 2 in sostituzione. (?:abc) è un gruppo non di acquisizione. (?=abc) è un lookahead (asserisce quanto segue). (?!abc) è un lookahead negativo. (?<=abc) è un lookbehind (ES2018+). a|b è l'alternanza (aob).
-
Flag: modifica il comportamento di corrispondenza
g = globale (trova tutte le corrispondenze, non solo la prima). i = senza distinzione tra maiuscole e minuscole. m = multilinea (^ e $ corrispondono ai limiti della linea). s = puntoAll (. corrisponde a nuova riga). u = unicode (tratta il modello come punti di codice Unicode; necessario per emoji e caratteri astrali). y = permanente (corrisponde solo a lastIndex).
Esempi
Abbina un indirizzo email (pratico, RFC 5322 semplificato)
Ingresso: Pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
Produzione: Corrisponde a "[email protected]" e "[email protected]" ma non a "plainaddress" o "@no-user.com"
Estrai tutti i codici colore esadecimali da CSS
Ingresso: Pattern: /#[0-9a-fA-F]{3,8}\b/g
Produzione: In 'color: #fff; background: #1a2b3c4d' finds ['#fff', '#1a2b3c4d']
Convalidare una data ISO 8601 (AAAA-MM-GG)
Ingresso: Pattern: /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/
Produzione: Corrisponde a "2026-08-28" ma rifiuta "2026-13-01" e "2026-02-31"
Sostituisci le cifre con # utilizzando un gruppo di acquisizione
Ingresso: 'Ordine 42 spedito' sostituito da /(\d+)/g →'#$1'
Produzione: 'Ordine n. 42 spedito'
Problemi comuni
- Quantificatori greedy che corrispondono troppo: '<.*>' su '<a><b>' corrisponde all'intera stringa '<a><b>' invece di '<a>'. Utilizzare '<.*?>' (pigro) per trovare prima la corrispondenza con '<a>'.
- Backtracking catastrofico: quantificatori annidati come (a+)+b sull'input 'aaaaaaaaaaaaaaaa!' può richiedere un tempo esponenziale. Riscrivere il modello o utilizzare gruppi atomici/quantificatori possessivi ove supportato.
- Dimenticando il flag u per Unicode: /^.$/ corrisponde a una singola unità di codice, quindi emoji come "😀" (due unità di codice) falliscono senza il flag u. Aggiungi sempre u quando abbini personaggi astrali.
- Confondere \b (confine di parola) con \s (spazio bianco): \b corrisponde tra una parola e un carattere non di parola, quindi funziona anche all'inizio/fine della stringa. \s corrisponde solo ai caratteri degli spazi bianchi effettivi.
Suggerimenti
- Testa sempre la regex rispetto ai campioni corrispondenti e non corrispondenti nel nostro Regex Tester prima di incorporarla nel codice di produzione: i casi limite sono facili da perdere.
- Preferisci le classi di caratteri [a-z] all'alternanza (a|b|...|z) per caratteri singoli: le classi sono più veloci e più chiare.
- Utilizza i gruppi non di acquisizione (?:...) quando non ti serve il valore acquisito: l'acquisizione ha un piccolo costo in termini di prestazioni e ingombra l'array dei risultati.
- Compila regex una volta con new RegExp() o un valore letterale nell'ambito del modulo, non all'interno di un hot loop: ricompilare lo stesso modello a ogni iterazione spreca CPU.