Panoramica (Cosa)
Questa guida tecnica è una referenza completa per l’uso pratico e portabile delle espressioni regolari. Include sintassi, gestione su più linee, tecniche di sostituzione, compatibilità tra strumenti e progettazione manutenibile dei pattern.
Obiettivo (Perché)
Le espressioni regolari sono fondamentali per la validazione, parsing, trasformazione ed estrazione dei dati testuali. Usate correttamente, permettono automazione, pulizia dati e analisi efficienti su qualsiasi linguaggio o piattaforma.
Parte 1: Sintassi Base
| Pattern |
Significato |
Esempio |
Match Esempio |
. |
Qualsiasi carattere tranne newline |
a.c |
abc, a-c |
* |
Ripeti 0 o più volte |
go*gle |
ggle, google |
+ |
Ripeti 1 o più volte |
go+gle |
gogle, google |
? |
0 o 1 occorrenze |
colou?r |
color, colour |
{n} |
Esattamente n volte |
a{3} |
aaa |
{n,m} |
Da n a m volte |
a{2,4} |
aa, aaa, aaaa |
^ |
Inizio riga |
^abc |
riga che inizia con abc |
$ |
Fine riga |
abc$ |
riga che finisce con abc |
[] |
Uno tra i caratteri |
[abc] |
a, b, c |
[^] |
Tutti tranne i caratteri specificati |
[^0-9] |
qualsiasi non cifra |
\d |
Cifra |
\d+ |
123, 007 |
\D |
Non cifra |
\D+ |
abc, XYZ |
\w |
Lettera, cifra o _ |
\w+ |
abc_123 |
\W |
Qualsiasi tranne \w |
\W+ |
#@!, spazi |
\s |
Spazio, tab o newline |
\s+ |
spazi, \n, \t |
\S |
Non spazio |
\S+ |
abc, 123 |
| ` |
` |
OR logico |
`foo |
() |
Gruppo |
(abc)+ |
abcabc |
\b |
Confine di parola |
\bregex\b |
solo la parola regex |
Parte 2: Pattern Utili (Supporto Multilingua)
| Uso |
Pattern |
Note |
| Solo cifre |
^\d+$ |
Solo numeri |
| Numero decimale |
^\d+\.\d+$ |
Include . |
| Solo alfanumerici |
^[a-zA-Z0-9]+$ |
ID utente |
| Email (semplificata) |
^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$ |
Base ma comune |
| URL (http/https) |
https?://[\w.-]+\.[a-zA-Z]{2,}(/[\w./?=&%-]*)? |
Query supportata |
| Data ISO |
\d{4}-\d{2}-\d{2} |
Formato AAAA-MM-GG |
| Telefono internazionale |
\+\d{1,3}[\s-]?\d{1,14} |
Esempio: +39 333... |
| Nome utente |
^[a-zA-Z0-9._-]{3,20}$ |
Username social |
| Password forte |
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ |
Almeno 8 con maiusc/minusc/cifre |
Parte 3: Matching Multilinea
🔹 Perché usare [\s\S]*?
Il pattern . non cattura newline in molti engine.
Soluzione consigliata:
[\s\S]*?
💡 Alcuni strumenti accettano [\s\S\n]*? per maggiore compatibilità.
🔹 Esempi Comuni
| Caso |
Pattern |
Note |
| Testo generico |
[\s\S]*? |
Match multilinea |
Blocco <div> |
<div[\s\S]*?</div> |
Intero blocco div |
| Commento HTML |
<!--[\s\S]*?--> |
Blocco commento |
| Codice Markdown |
"[\s\S]*?" |
Blocchi di codice con ` |
Parte 4: Tecniche di Sostituzione
🔹 Sintassi per gruppi
${1}, ${2} (VSCode, Python, .NET)$1, $2 (JavaScript, sed)
🔹 Esempi Pratici
| Obiettivo |
Pattern |
Sostituzione |
| Inverti due parole |
(\w+)\s+(\w+) |
${2} ${1} |
Wrappa testo in <span> |
>([^<]+)< |
><span>${1}</span>< |
| CSV → JSON |
^([^,]+),([^,]+),([^,]+)$ |
{ "a": "${1}", "b": "${2}", "c": "${3}" } |
Data: AAAA/MM/GG → - |
(\d{4})/(\d{2})/(\d{2}) |
${1}-${2}-${3} |
| Camel → snake_case |
([a-z])([A-Z]) |
${1}_${2} |
Parte 5: Compatibilità tra Strumenti
| Strumento |
Multilinea |
Non-greedy |
Sintassi Sostituzione |
Note |
| VSCode |
✅ (search) |
✅ |
${1} |
[\s\S]*? raccomandato |
| JavaScript |
✅ (/s) |
✅ |
$1, $<name> |
Supporta gruppi nominati |
Python (re) |
✅ (DOTALL) |
✅ |
\g<1> / \1 |
Consigliato r"" raw string |
| sed |
❌ |
❌ |
\1, \2 |
Solo sostituzioni base |
| grep/egrep |
❌ |
❌ |
❌ |
Solo ricerca, niente sostituzioni |
Parte 6: Best Practices & Anti-pattern
✅ Buone Pratiche
- Usa
[\s\S]*? per multilinea
- Evita
.* in favor di non-greedy
- Per gruppi non catturanti:
(?:...)
- Usa gruppi nominati:
(?<anno>\d{4})
- Commenta espressioni complesse (
re.VERBOSE)
❌ Anti-pattern
| Pattern |
Problema |
.* |
Match troppo ampio, risultati imprevisti |
[^a-z] |
Non supporta caratteri accentati |
| Nesting |
HTML/XML profondi non gestibili via regex |
.+ |
Matcha anche righe vuote o bianche |
Conclusione
Questa guida è una referenza definitiva per l’uso robusto e manutenibile delle espressioni regolari in contesti reali.
In ambienti multilinea, considera [\s\S]*? come standard de facto e adatta la sintassi in base allo strumento usato.
Una regex ben progettata è uno strumento potente, riutilizzabile e comprensibile nel tempo.
