Guida rapida alle espressioni regolari e pattern comuni
Le espressioni regolari, o regex, sono un potente strumento di pattern matching utilizzato in quasi tutti i linguaggi di programmazione ed editor di testo. Sebbene la sintassi possa sembrare criptica a prima vista, padroneggiare le regex ti consente di cercare, validare, estrarre e trasformare testo con una precisione che richiederebbe decine di righe di codice procedurale. Questa guida copre la sintassi di base, i pattern comuni e i consigli pratici che devi conoscere.
Guida rapida alla sintassi di base delle regex
Classi di caratteri
| Pattern | Significato | Esempio |
|---|---|---|
| . | Qualsiasi carattere tranne il newline | a.c corrisponde a abc, a1c, a c |
| \d | Qualsiasi cifra (0-9) | \d\d corrisponde a 42 |
| \D | Qualsiasi carattere non cifra | \D corrisponde a a, !, spazio |
| \w | Carattere di parola (a-z, A-Z, 0-9, _) | \w+ corrisponde a hello_123 |
| \W | Carattere non di parola | \W corrisponde a @, #, spazio |
| \s | Carattere di spazio bianco (spazio, tab, newline) | a\sb corrisponde a a b |
| \S | Carattere non di spazio bianco | \S+ corrisponde a hello |
| [abc] | Qualsiasi carattere nell'insieme | [aeiou] corrisponde a vocali |
| [^abc] | Qualsiasi carattere non nell'insieme | [^0-9] corrisponde a non cifre |
| [a-z] | Intervallo di caratteri | [A-Za-z] corrisponde a qualsiasi lettera |
Quantificatori
| Pattern | Significato | Esempio |
|---|---|---|
| * | Zero o più volte | ab*c corrisponde a ac, abc, abbc |
| + | Una o più volte | ab+c corrisponde a abc, abbc |
| ? | Zero o una volta | colou?r corrisponde a color, colour |
| {n} | Esattamente n volte | \d{4} corrisponde a 4 cifre |
| {n,} | n o più volte | \d{2,} corrisponde a 2 o più cifre |
| {n,m} | Da n a m volte | \d{3,5} corrisponde a 3-5 cifre |
Ancore e limiti
| Pattern | Significato | Esempio |
|---|---|---|
| ^ | Inizio della stringa o della riga | ^Hello corrisponde a Hello all'inizio |
| $ | Fine della stringa o della riga | world$ corrisponde a world alla fine |
| \b | Limite di parola | \bcat\b corrisponde a cat isolato |
| \B | Non limite di parola | \Bcat corrisponde a scattered |
Raggruppamento e alternanza
| Pattern | Significato | Esempio |
|---|---|---|
| (abc) | Gruppo di cattura | (ab)+ corrisponde a abab |
| (?:abc) | Gruppo non catturante | (?:ab)+ corrisponde a abab |
| a|b | Alternanza (o) | cat|dog corrisponde a cat o dog |
| \1 | Riferimento all'indietro al gruppo 1 | (\w)\1 corrisponde a aa, bb |
| Gruppo di cattura con nome | Riferito come name |
Pattern regex comuni
Ecco i pattern regex più comunemente usati nello sviluppo web e nella validazione dei dati:
Validazione email
Una regex pratica per la validazione email che cattura la maggior parte degli indirizzi non validi senza essere troppo restrittiva: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ . Questo pattern valida la struttura di base dell'email consentendo i caratteri comuni nella parte locale e richiedendo un dominio valido con un TLD di almeno due caratteri.
Validazione URL
Corrisponde a URL HTTP e HTTPS: ^https?:\/\/(www\.)?[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(\/[^\s]*)?$ . Questo pattern corrisponde a URL con prefisso www opzionale, nome di dominio e percorso opzionale.
Numero di telefono (USA)
Vari formati di numeri di telefono USA: ^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$ . Questo pattern gestisce formati come (555) 123-4567, 555-123-4567 e 5551234567.
Indirizzo IP (IPv4)
Convalida indirizzi IPv4: ^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$ . Questo pattern garantisce che ogni ottetto sia compreso tra 0 e 255.
Data (YYYY-MM-DD)
Formato data ISO: ^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$ . Questo pattern valida la struttura del formato ma non controlla le date valide per ogni mese.
Codice colore esadecimale
Corrisponde ai colori esadecimali CSS: ^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ . Questo pattern corrisponde sia ai formati abbreviati a 3 cifre (#fff) che a 6 cifre (#ffffff).
Tecniche avanzate
Lookahead e lookbehind
Le asserzioni lookahead e lookbehind ti consentono di corrispondere a un pattern solo quando è seguito (o preceduto) da (o non da) un altro pattern, senza includere il testo circostante nel risultato della corrispondenza.
- Lookahead positivo (?=pattern): Corrisponde solo se il pattern è davanti. Esempio: \d(?=px) corrisponde alle cifre seguite da "px".
- Lookahead negativo (?!pattern): Corrisponde solo se il pattern non è davanti. Esempio: \d(?!px) corrisponde alle cifre non seguite da "px".
- <=pattern): Corrisponde solo se il pattern è dietro. Esempio: (?<=\$)\d+ corrisponde alle cifre precedute da un simbolo del dollaro.
Corrispondenza greedy vs lazy
<.*>bold<.*?>".
Consigli sulle prestazioni delle regex
- Usa gruppi non catturanti (?:) quando non hai bisogno di estrarre il contenuto del gruppo corrispondente
- Usa quantificatori possessivi o gruppi atomici quando supportati per evitare un backtracking eccessivo
- Usa classi di caratteri specifiche invece del carattere jolly punto in modo estensivo
- Ancora i tuoi pattern con ^ e $ quando devi corrispondere all'intera stringa
- Precompila i pattern regex quando li riutilizzi nei cicli
- Usa i limiti di parola \b invece di ^ e $ quando cerchi in testi più grandi
Testare e debuggare le regex
Testa sempre i tuoi pattern regex con input reali prima di distribuirli. Usa un tester regex interattivo che evidenzia le corrispondenze in tempo reale e spiega ogni parte del pattern. Questo ti aiuta a catturare i casi limite e a capire perché un pattern corrisponde o non corrisponde a un input specifico. Prova il nostro tester regex gratuito per costruire e testare i tuoi pattern in modo interattivo.
Usa i nostri strumenti gratuiti per costruire, testare e debuggare i tuoi pattern regex.
Prova il tester regexGuida rapida regexDomande frequenti
Qual è la differenza tra corrispondenza regex greedy e lazy?
I quantificatori greedy corrispondono a quanto più testo possibile, mentre i quantificatori lazy corrispondono a quanto meno testo possibile. Aggiungere un punto interrogativo dopo un quantificatore lo rende lazy. Ad esempio, .* corrisponde alla stringa più lunga possibile, mentre .*? corrisponde alla più corta.
Le regex sono uguali in tutti i linguaggi di programmazione?
No, le implementazioni delle regex variano tra i linguaggi. La maggior parte supporta la sintassi POSIX di base, ma funzionalità avanzate come lookbehind, gruppi nominati e supporto Unicode differiscono. JavaScript ha storicamente avuto un supporto limitato per le regex, ma ha aggiunto molte funzionalità negli ultimi anni.
Le regex possono analizzare HTML o XML?
No, le regex non possono analizzare in modo affidabile HTML o XML perché sono linguaggi liberi dal contesto e annidati. Le regex non hanno il concetto di profondità di annidamento o bilanciamento dei tag. Usa un parser HTML o XML appropriato. Le regex possono estrarre pattern semplici dall'HTML, ma falliranno su strutture complesse.
Cosa sono lookahead e lookbehind nelle regex?
<=pattern) è un lookbehind positivo, corrisponde se il pattern è dietro. Le versioni negative usano ! invece di =.
Come rendere una regex non case-sensitive?
Aggiungi il flag i dopo il delimitatore di chiusura per rendere l'intero pattern non case-sensitive. In JavaScript, usa /pattern/i. In Python, usa re.IGNORECASE o re.I come flag. Puoi anche usare (?i) inline per rendere non case-sensitive una parte specifica.
ToolHub's collection of 300+ free online tools including regex tester, cheat sheets, and more — no sign-up required.