Regexper Svogliati
Le espressioni regolari: quella fila di simboli che sembra un gatto che ha camminato sulla tastiera e invece trova tutti gli IP in un log in mezzo secondo. Come si leggono, come si scrivono, in quale dialetto, e quando lasciar perdere.
"Ho un problema, lo risolvo con una regex." — Adesso hai due problemi. (Jamie Zawinski, 1997, più o meno)
Cos'è una regex, e quando non usarla
Un modo di descrivere la forma di un testo, invece del testo esatto. Non "cerca 192.168.1.1", ma "cerca quattro numeri separati da punti".
Il "cerca" normale trova solo la parola che scrivi, lettera per lettera. Una regex è uno stampo: descrive una forma, e trova tutti i pezzi di testo che ci entrano. "Tre cifre, un trattino, quattro cifre" trova 555-1234 e 123-4567 senza che tu sappia in anticipo quali sono.
Dove è insostituibile
- Filtrare log: tutti gli errori 5xx, tutti gli IP che hanno chiesto
/wp-login.php - Trovare e sostituire in tanti file con
sed - Controllare che un campo abbia la forma giusta: un codice postale, una data
- fail2ban, nginx, Postfix, i filtri di posta: le parlano tutti
Dove fa danni
- HTML e XML: si annidano all'infinito, una regex non li segue. Usa un parser
- JSON:
jq, o il modulojsondi Python - Email "valide": lo standard permette cose assurde. Controlla che ci sia una chiocciola e manda una mail di conferma
- Qualunque cosa che un normale
splitostartswithrisolve in una riga
Un po' di storia
Nate per descrivere i neuroni, finite dentro ogni editor del pianeta.
Kleene e i neuroni
Il matematico Stephen Kleene inventa una notazione per descrivere gli "eventi regolari" di una rete di neuroni artificiali. La stella *, "ripeti quante volte vuoi", si chiama ancora oggi stella di Kleene.
Thompson le mette in un editor
Ken Thompson pubblica un metodo per trasformare una regex in un programma che la cerca, e lo mette nel suo editor di testo. Poco dopo arriverà Unix, con l'editor ed.
grep
Il comando di ed per stampare le righe che corrispondono era g/re/p: global, regular expression, print. Thompson lo trasforma in un programma a sé. Il nome è rimasto.
Perl
Larry Wall crea Perl, e le regex diventano un pezzo del linguaggio, con aggiunte che grep non aveva: \d, i quantificatori pigri, e più avanti gli sguardi in avanti e indietro.
PCRE
Philip Hazel, per il suo server di posta Exim, scrive una libreria che fa "le regex come Perl" in C. PCRE finisce in PHP, Apache, nginx, nei firewall: è il dialetto più diffuso al mondo.
La regex che spense mezzo internet
Una regola del firewall applicativo di Cloudflare con una regex scritta male manda al 100% le CPU di tutto il mondo per mezz'ora. Ci arriviamo alla sezione 12.
I mattoni
Una manciata di simboli. Tutto il resto è combinarli.
| Scrivi | Vuol dire | Esempio |
|---|---|---|
abc | Proprio quelle lettere | error trova "error" |
. | Un carattere qualsiasi (tranne l'a capo) | c.t: cat, cut, c9t |
\. | Un punto vero: la barra toglie il superpotere | www\.selif |
[abc] | Una sola lettera fra quelle | gr[ae]y: gray, grey |
[0-9], [a-z] | Un carattere nell'intervallo | [0-9][0-9]: due cifre |
[^0-9] | Tutto tranne quelli: il ^ dentro le quadre nega | un carattere che non è una cifra |
\d \w \s | Cifra, lettera/cifra/trattino basso, spazio (non in tutti i dialetti, sezione 8) | \d\d |
^ e $ | Inizio e fine della riga | ^#: righe che cominciano con # |
\b | Confine di parola | \bcat\b trova cat ma non concatena |
Quante volte, e l'ingordigia
I quantificatori dicono quante volte ripetere il pezzo prima. E di default sono avidi: prendono più che possono.
| Scrivi | Quante volte | Esempio |
|---|---|---|
* | Zero o più | ab*c: ac, abc, abbbc |
+ | Una o più | [0-9]+: un numero di qualsiasi lunghezza |
? | Zero o una: facoltativo | https?: http e https |
{3} | Esattamente tre | [0-9]{3} |
{1,3} | Da una a tre | [0-9]{1,3}: un pezzo di IP |
*? +? | Come sopra, ma pigri: il meno possibile | sotto |
Con <.+> su <b>uno</b> ti aspetteresti di trovare <b>, e invece trovi tutta la riga: il .+ mangia fino all'ultimo > che riesce a vedere. Con <.+?>, pigro, si ferma al primo. È l'errore più comune in assoluto, e infatti è il motivo per cui l'HTML non si fa con le regex.
Gruppi, alternative, richiami
Le parentesi fanno due lavori: tengono insieme un pezzo per ripeterlo, e ne ricordano il contenuto per usarlo dopo.
| Scrivi | Fa | Esempio |
|---|---|---|
(abc) | Gruppo: si ripete in blocco e si ricorda | (ab)+: ab, abab |
a|b | Uno o l'altro | (GET|POST) |
\1 | Quello che ha catturato il gruppo 1, di nuovo | (\w+) \1: "il il", parole ripetute |
(?:abc) | Gruppo che non ricorda: solo per raggruppare | (?:www\.)?selif |
(?P<nome>…) (Python) o (?<nome>…) | Gruppo con un nome, che poi leggi per nome | sezione 10 |
sed e in Python il gruppo catturato si rimette nel testo nuovo con \1, \2. È così che si rigira una data da 06/11/2026 a 2026-11-06 in un colpo solo: sezione 9.
Provala qui
Scrivi una regex, incolla un testo, e guarda cosa prende. È il dialetto JavaScript, molto vicino a PCRE e Python.
Guardare avanti e indietro
Condizioni che controllano cosa c'è prima o dopo, senza mangiarlo. Potenti, e solo in alcuni dialetti.
| Scrivi | Vuol dire | Esempio |
|---|---|---|
(?=…) | Seguito da… | [0-9]+(?=€): il numero, senza il simbolo |
(?!…) | Non seguito da… | \bfoo(?!bar) |
(?<=…) | Preceduto da… | (?<=user=)\w+: solo il nome utente |
(?<!…) | Non preceduto da… | (?<!\.)\bcom\b |
^(?=.*\d)(?=.*[A-Z]).{8,}$
# ogni (?=…) controlla una condizione e torna all'inizio;
# poi .{8,} prende tutto, se è lungo almeno 8
grep -E e sed non li conoscono. Servono PCRE (grep -P su Linux), Python, JavaScript, Perl, PHP.
I dialetti
"Regex" non è una lingua sola. È una famiglia di dialetti che si somigliano abbastanza da ingannarti.
| Dialetto | Dove | Cosa cambia |
|---|---|---|
| BRE (base) | grep, sed senza opzioni | + ? | ( ) { } sono caratteri normali: per usarli come operatori serve la barra, \( \{3\} |
| ERE (estese) | grep -E, sed -E, awk | Gli operatori funzionano senza barra. Niente \d: si scrive [0-9] |
| PCRE | grep -P, PHP, nginx, Perl | Tutto: \d, pigri, sguardi avanti e indietro, gruppi con nome |
Python re | Script | Come PCRE quasi in tutto; gruppi con nome (?P<nome>) |
| JavaScript | Browser, Node | Come Python, opzioni scritte dopo la barra: /…/gi |
grep del Mac non ha -P: risponde "invalid option". E sed -i -E 's/a/b/' file sul Mac non modifica in silenzio: prende -E come estensione del backup e ti lascia un file file-E. Sul Mac si scrive sed -i '' -E. Il perché è nella guida GNU; la soluzione è installare grep e sed di GNU con Homebrew, o provare sul server.
grep e sed nella pratica
Il novanta per cento delle regex di un sistemista passa da qui.
# le righe vere di un file di configurazione: niente commenti, niente righe vuote
grep -Ev '^\s*(#|$)' /etc/ssh/sshd_config
# solo la parte che corrisponde (-o): tutti gli IP di un file
grep -oE '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' file.txt
# quante righe di errore 5xx nel log di nginx
grep -cE '" 5[0-9]{2} ' /var/log/nginx/access.log
# parole ripetute per sbaglio ("il il")
grep -E '\b(\w+) \1\b' testo.txt
# girare una data da 06/11/2026 a 2026-11-06
echo "06/11/2026" | sed -E 's#([0-9]{2})/([0-9]{2})/([0-9]{4})#\3-\2-\1#'
# il # al posto della / evita di dover scrivere \/ dentro la regex
# cambiare un valore in un file (Linux; sul Mac: sed -i '' -E …)
sed -i -E 's/^#?PasswordAuthentication .*/PasswordAuthentication no/' /etc/ssh/sshd_config
sed -iprova lo stesso comando senza -i: stampa il risultato a schermo e non tocca il file. Oppure sed -i.bak, che lascia la copia originale accanto.
Python
Quando la regex diventa più lunga di una riga, o il risultato deve finire in uno script.
import re
riga = '203.0.113.7 - - [06/Nov/2026:10:12:01 +0100] "GET /index.html HTTP/2.0" 200 5123 "-" "Mozilla/5.0"'
m = re.match(r'(?P<ip>\S+) \S+ \S+ \[(?P<ora>[^\]]+)\] "(?P<metodo>\w+) (?P<path>\S+)[^"]*" (?P<stato>\d{3})', riga)
print(m.group('ip'), m.group('metodo'), m.group('path'), m.group('stato'))
# 203.0.113.7 GET /index.html 200
| Funzione | Fa |
|---|---|
re.search(r, s) | La prima corrispondenza, ovunque nel testo |
re.match(r, s) | Solo se il testo comincia così |
re.findall(r, s) | Tutte, in una lista |
re.sub(r, nuovo, s) | Sostituisce; nel testo nuovo \1 e \g<nome> |
re.compile(r) | La prepara una volta, se la usi mille volte in un ciclo |
r'\d+', non '\d+'. Senza la r Python interpreta le barre per conto suo prima ancora che la regex le veda, e \b diventa un carattere di controllo invece del confine di parola.
Ricette da sistemista
Quelle che finiscono davvero negli script e nelle configurazioni.
| Cosa | Regex | Nota |
|---|---|---|
| Un IPv4, alla buona | \b([0-9]{1,3}\.){3}[0-9]{1,3}\b | Prende anche 999.1.1.1. Per trovare negli log basta; per validare, usa il modulo ipaddress |
| Righe vere di una config | ^\s*[^#\s] | Comincia con qualcosa che non è spazio né # |
| Una data gg/mm/aaaa | \b[0-3][0-9]/[01][0-9]/[0-9]{4}\b | Il 31/02 lo prende lo stesso: la forma è giusta, il calendario no |
| Codice di stato HTTP nel log | " ([45][0-9]{2}) | Gli errori 4xx e 5xx, catturati nel gruppo |
| Una MAC address | ([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2} | Con i due punti; per i trattini cambia il separatore |
# /etc/fail2ban/filter.d/wp-login.conf
[Definition]
failregex = ^<HOST> -.*"(GET|POST) /wp-login\.php
# <HOST> non è regex: fail2ban lo sostituisce con la sua regex per IP e nomi
# prova prima del vero: fail2ban-regex /var/log/nginx/access.log /etc/fail2ban/filter.d/wp-login.conf
Le regex di fail2ban sono quelle di Python. Come scrivere il resto del filtro e la jail è nella guida fail2ban e CrowdSec.
Regex che esplodono
La maggior parte dei motori regex, quando una strada non va, torna indietro e prova le altre. Con la regex sbagliata, le strade da provare diventano miliardi.
(a+)+$ su una fila di "a" seguita da un "!" non può funzionare, ma il motore non lo sa: prova tutti i modi di dividere le "a" fra il + dentro e il + fuori. Ogni lettera in più raddoppia il lavoro. I tempi del grafico li ho misurati con Python su un portatile: con 24 lettere sono già un terzo di secondo, con 30 sarebbero una ventina di secondi, con 40 diverse ore.
.* uno dentro l'altro: su certe richieste il motore comincia a tornare indietro senza fine, e le CPU dei server di tutto il mondo vanno al 100%. Mezz'ora di errori 502 per moltissimi siti. Nel resoconto Cloudflare ha annunciato il passaggio a un motore regex che per costruzione non torna indietro. La storia è nella guida Cloudflare.
Per stare tranquillo
- Niente quantificatori annidati sullo stesso testo:
(a+)+,(.*)*,(\w+\s?)+ - Classi precise al posto di
.*:[^"]*dentro le virgolette - Ancore
^e$quando sai dove comincia e finisce - Un limite alla lunghezza dell'input, se la regex gira su testo che arriva da fuori
ReDoS
- Si chiama ReDoS (DoS da regex) quando qualcuno manda apposta il testo che fa esplodere una tua regex
- Basta una richiesta per tenere occupato un processo per secondi
- I motori senza ritorno indietro (RE2, Rust, Go) ne sono immuni, ma non hanno i richiami
\1né gli sguardi indietro
Scriverle bene
Una regex si scrive una volta e si legge cento. Di solito la legge qualcuno che ti odia, cioè tu fra sei mesi.
IP = re.compile(r"""
\b
(?:[0-9]{1,3}\.){3} # tre numeri seguiti da un punto
[0-9]{1,3} # il quarto numero
\b
""", re.VERBOSE)
# con re.VERBOSE spazi e a capo non contano e # comincia un commento
Esempi veri
Tieni accanto una manciata di righe che deve prendere e una che non deve prendere. Prima di cambiare la regex, provala su tutte.
Un tester
Quello della sezione 6, oppure regex101.com, che spiega pezzo per pezzo cosa fa ogni simbolo e supporta più dialetti.
Spezzala
Due regex semplici in fila, o una regex più un if, sono meglio di un mostro che fa tutto.
Errori tradotti
Quello che dice il messaggio, e quello che vuole dire davvero.
| Succede | Vuol dire | Cosa fare |
|---|---|---|
grep: invalid option -- P | Sei sul Mac, o su un grep senza PCRE | grep -E con [0-9] al posto di \d, o il grep di GNU |
Con grep -E il \d non trova niente | ERE non conosce \d | [0-9] |
Con grep senza -E il + non funziona | In BRE è un carattere normale | grep -E, oppure \+ |
unterminated character set / missing ) | Manca una ] o una ) | Contale. O hai scritto [ volendo dire una quadra vera: \[ |
| Prende troppo | Un .* avido | .*?, o una classe come [^"]* |
| Il punto prende qualunque cosa | Volevi un punto vero | \. |
| Uno script si pianta su certe righe | Ritorno indietro catastrofico | Sezione 12 |
Accanto al file compare file-E | sed -i -E sul Mac | sed -i '' -E |
Cheat sheet
Tutta la guida in una schermata.
| Simbolo | Vuol dire |
|---|---|
. / \. | Un carattere qualsiasi / un punto vero |
[abc] [^abc] [0-9] | Uno di questi / nessuno di questi / un intervallo |
\d \w \s | Cifra, carattere di parola, spazio (non in ERE) |
^ $ \b | Inizio riga, fine riga, confine di parola |
* + ? {n,m} | Zero o più, uno o più, facoltativo, da n a m |
*? +? | Le versioni pigre |
( ) (?: ) | | Gruppo, gruppo che non ricorda, alternativa |
\1 | Di nuovo quello del gruppo 1 |
(?= ) (?! ) (?<= ) (?<! ) | Seguito, non seguito, preceduto, non preceduto |
grep -E · grep -P · sed -E | Estese · Perl (solo Linux) · estese in sed |
🧘 I cinque comandamenti
- Prima chiediti se basta un
split - Niente HTML, JSON ed email "valide"
- Sappi in che dialetto stai scrivendo
- Diffida di
.*, mai quantificatori annidati - Provala su esempi veri prima di metterla in produzione
📖 Da leggere dopo
- Bash: grep, sed e awk negli script
- fail2ban e CrowdSec: le regex che bannano
- Python: quando la regex non basta
- GNU: perché il Mac fa diverso
.* avido. Mai HTML e JSON, mai quantificatori uno dentro l'altro, e provala sempre su esempi veri."