Pattern Regex Comuni che Ogni Sviluppatore Dovrebbe Salvare nei Preferiti

I pattern regex sono template riutilizzabili che individuano sequenze specifiche di caratteri all'interno di un testo - pensali come uno strumento di ricerca potenziato, compatibile con quasi tutti i linguaggi di programmazione. Che tu stia validando un indirizzo email, estraendo un numero di telefono da un form o analizzando un file di log, un insieme ben scelto di espressioni regolari copre il 90% delle situazioni reali. Questa guida raccoglie i pattern più utili, spiega esattamente cosa fa ciascuno e mostra come adattarli al tuo caso.

Ripasso rapido della sintassi regex

Prima di entrare nei pattern veri e propri, ecco un riferimento rapido ai costrutti di base che incontrerai più spesso. Anche se hai già lavorato con le espressioni regolari, averli tutti in un unico posto è sempre comodo.

La guida alle espressioni regolari di MDN Web Docs è il riferimento più completo per la sintassi regex in JavaScript, e la maggior parte dei pattern qui sotto si trasferisce direttamente a Python, PHP, Java e Ruby con minime differenze sui flag.

Validazione delle email

La validazione delle email è il caso d'uso classico per le espressioni regolari - ed è anche quello in cui più sviluppatori sbagliano cercando di essere troppo rigidi. La specifica RFC 5322 consente tecnicamente indirizzi come "very unusual"@example.com , che quasi nessuna regex gestisce correttamente. Per il 99% della validazione reale, usa un pattern pragmatico:

^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$

Cosa fa ogni parte:

• [a-zA-Z0-9._%+\-]+ - la parte locale (prima della @); ammette punti, segni più, trattini e underscore
• @ - il simbolo @ letterale
• [a-zA-Z0-9.\-]+ - il nome di dominio, inclusi i sottodomini
• \.[a-zA-Z]{2,} - TLD di almeno 2 caratteri (.io, .com, .museum)

URL e indirizzi web

Il pattern matching sugli URL copre tutto, dall'estrazione di link da testo semplice alla validazione di un campo sito web compilato dall'utente.

https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_+.~#?&\/=]*)

• https? - corrisponde sia a http che a https
• (?:www\.)? - prefisso www opzionale
• [-a-zA-Z0-9@:%._+~#=]{1,256} - caratteri dell'hostname, fino a 256 caratteri
• \.[a-zA-Z0-9()]{1,6} - TLD
• \b(?:[-a-zA-Z0-9()@:%_+.~#?&\/=]*) - path, query string e fragment opzionali

Se hai bisogno solo di validare (non di estrarre), racchiudi il pattern con gli anchor ^ e $ .

Numeri di telefono

I numeri di telefono sono notoriamente difficili da gestire perché la formattazione varia moltissimo da paese a paese e in base alle abitudini degli utenti. Due pattern coprono la maggior parte degli scenari:

Formato US/Canada (NANP)

^(\+1[-.\s]?)?(\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}$

Corrisponde a: 555-867-5309 , (555) 867 5309 , +1.555.867.5309 , 5558675309

Formato internazionale (E.164)

^\+[1-9]\d{6,14}$

E.164 è il formato utilizzato dalla maggior parte delle API di telefonia (Twilio, AWS SNS). Inizia con + seguito dal prefisso internazionale, senza spazi né punteggiatura.

Date e orari

Il pattern matching sulle date è frequente nei parser di log, nei validatori di form e nelle pipeline di dati. Il formato da scegliere dipende dalla sorgente del tuo input.

ISO 8601 (YYYY-MM-DD)

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

Formato US (MM/DD/YYYY)

^(0[1-9]|1[0-2])\/(0[1-9]|[12]\d|3[01])\/\d{4}$

Orario in formato 24 ore (HH:MM o HH:MM:SS)

^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$

Tieni presente che questi pattern validano il formato, non la logica del calendario. Accetteranno anche 2024-02-31 (il 31 febbraio non esiste). Per una validazione rigorosa delle date, analizzale con la libreria date del tuo linguaggio dopo il controllo regex.

Validazione della robustezza delle password

Le regole sulle password richiedono tipicamente una combinazione di tipi di caratteri e una lunghezza minima. I lookahead rendono tutto più pulito, evitando di fare controlli separati.

Minimo 8 caratteri, almeno una maiuscola, una minuscola e una cifra

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$

Robusta: 8+ caratteri, maiuscola, minuscola, cifra e carattere speciale

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]).{8,}$

Ogni (?=.*[...]) è un lookahead che scansiona l'intera stringa alla ricerca di almeno un carattere corrispondente. Il .{8,} finale impone la lunghezza minima. Puoi sostituire {8,} con {12,} per richiedere almeno 12 caratteri, in linea con le linee guida NIST SP 800-63B .

Indirizzi IP

IPv4

^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$

Questo pattern rifietta correttamente valori come 999.0.0.1 , verificando esplicitamente che ogni ottetto sia compreso tra 0 e 255.

IPv6 (semplificato)

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Questo pattern gestisce il formato completo a 8 gruppi. Per la notazione compressa (ad es. ::1 per il loopback), il pattern diventa significativamente più complesso - in quel caso, usare una libreria di rete è più affidabile della regex.

HTML e markup

Alcuni pattern mirati sono genuinamente utili in questo contesto. Il consiglio generale "non analizzare HTML con la regex" vale ancora per i documenti completi - usa un parser DOM appropriato come BeautifulSoup o DOMParser per quello. Ma per operazioni specifiche e delimitate, la regex funziona benissimo.

Rimuovere tutti i tag HTML

<[^>]*>

Estrarre il contenuto da un tag specifico (es. <title>)

Il gruppo di cattura 1 contiene il testo del titolo.

Trovare i codici colore esadecimali HTML

#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})\b

Corrisponde sia alla forma abbreviata a 3 cifre ( #fff ) che a quella completa a 6 cifre ( #ffffff ).

Pattern di utilità quotidiana

Questi pattern si presentano continuamente in progetti di ogni tipo.

Slug (stringa compatibile con gli URL)

^[a-z0-9]+(?:-[a-z0-9]+)*$

Corrisponde a stringhe come my-blog-post-2024 . Niente maiuscole, niente trattini iniziali o finali, niente trattini doppi.

Numero di carta di credito (formato base, senza spazi)

^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12})$

• Inizia con 4 - Visa (13 o 16 cifre)
• Inizia con 51-55 - Mastercard (16 cifre)
• Inizia con 34 o 37 - Amex (15 cifre)
• Inizia con 6011 o 65 - Discover (16 cifre)

Normalizzazione degli spazi bianchi (riduzione di spazi multipli)

\s{2,}

Sostituisci le corrispondenze con un singolo spazio per ripulire input utente disordinati o testi ottenuti tramite scraping.

Solo cifre

^\d+$

Solo caratteri alfanumerici

^[a-zA-Z0-9]+$

Trovare una riga che contiene una parola (case-insensitive con flag)

^.*\bword\b.*$

Il word boundary \b impedisce di trovare corrispondenze con word all'interno di password .

Estrarre numeri di versione (semver)

\bv?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.]+))?(?:\+([a-zA-Z0-9.]+))?\b

Cattura major, minor, patch, etichetta pre-release e metadati di build da stringhe come v2.14.0-beta.1+build.42 .

Flag e consigli pratici

I pattern regex si comportano diversamente a seconda dei flag applicati. Ecco quelli più comunemente necessari:

Alcune abitudini che ti faranno risparmiare tempo nel debug:

• Testa sempre con i casi limite - stringa vuota, lunghezza massima, caratteri Unicode e stringhe quasi valide ma non del tutto.
• Usa i gruppi non catturanti (?:...) quando non hai bisogno del contenuto catturato - sono più veloci e più puliti dei gruppi catturanti.
• Ancora i tuoi pattern di validazione con ^ e $ , così una sottostringa apparentemente valida all'interno di una stringa non valida non sfugge al controllo.
• Attenzione al backtracking catastrofico - quantificatori annidati come (a+)+ possono bloccare il motore regex su input appositamente costruiti. Mantieni i quantificatori semplici e specifici.
• Usa un tester regex mentre costruisci i pattern. regex101.com mostra in tempo reale la suddivisione delle corrispondenze, spiega ogni token e ti permette di passare tra PCRE, JavaScript, Python e altri flavor.

Testa e valida i tuoi pattern regex senza incertezze

Costruire pattern regex affidabili per la validazione dell'input è molto più rapido con gli strumenti giusti a portata di mano. Esplora i nostri strumenti gratuiti per sviluppatori per pulire, verificare e trasformare testo usando pattern regex e molto altro.

Prova i nostri strumenti gratuiti →