Regex per Principianti: 10 Pattern Utili da Conoscere

Cosa Sono le Espressioni Regolari

Le espressioni regolari (regex) sono pattern di ricerca che permettono di trovare, validare e manipolare testo con precisione chirurgica. Sono uno strumento fondamentale per ogni sviluppatore, utilizzato dalla validazione email al parsing di log, dalla ricerca nel codice all'estrazione di dati. Questa guida presenta i 10 pattern più utili con esempi pratici e spiegazioni dettagliate.

Sintassi Base

Caratteri Speciali

Simbolo	Significato	Esempio	Match
.	Qualsiasi carattere	a.c	abc, a1c, a@c
^	Inizio stringa	^Hello	"Hello World"
$	Fine stringa	World$	"Hello World"
*	0 o più volte	ab*c	ac, abc, abbc
+	1 o più volte	ab+c	abc, abbc (non ac)
?	0 o 1 volta	colou?r	color, colour
\d	Cifra [0-9]	\d{3}	123, 456
\w	Word char [a-zA-Z0-9_]	\w+	hello, user_1
\s	Spazio bianco	a\sb	"a b"

Quantificatori

# Quantificatori esatti
\d{3}      # Esattamente 3 cifre
\d{2,4}    # Da 2 a 4 cifre
\d{3,}     # 3 o più cifre

# Quantificatori greedy vs lazy
.*         # Greedy: match più lungo possibile
.*?        # Lazy: match più corto possibile

# Esempio
"
text
" con pattern <.*>
# Greedy: match tutto "
text
"
# Lazy <.*?>: match solo "
"

Pattern 1: Email

# Pattern base (funziona per la maggior parte dei casi)
^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$

# Spiegazione:
# ^           - Inizio stringa
# [\w.-]+     - Username: lettere, numeri, underscore, punto, trattino
# @           - Simbolo chiocciola
# [\w.-]+     - Dominio
# \.          - Punto (escaped)
# [a-zA-Z]{2,} - TLD di almeno 2 lettere
# $           - Fine stringa

# JavaScript
const emailRegex = /^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$/;
emailRegex.test('user@example.com');  // true
emailRegex.test('invalid@');          // false

# Match:
# user@example.com ✓
# name.surname@company.co.uk ✓
# test@domain ✗ (no TLD)

Pattern 2: URL

# Pattern completo
^https?:\/\/[\w.-]+(?:\/[\w./?%&=-]*)?$

# Spiegazione:
# ^https?     - http o https
# :\/\/       - ://
# [\w.-]+     - Dominio
# (?:...)?    - Gruppo non-catturante opzionale
# [\w./?%&=-]* - Path e query string

# JavaScript
const urlRegex = /^https?:\/\/[\w.-]+(?:\/[\w.\/?%&=-]*)?$/;

# Match:
# https://example.com ✓
# http://sub.domain.com/path?query=value ✓
# ftp://server.com ✗ (solo http/https)

Pattern 3: Numero di Telefono

# Telefono italiano
^(?:\+39)?[\s.-]?(?:3\d{2}|0\d{1,4})[\s.-]?\d{6,8}$

# Spiegazione:
# (?:\+39)?   - Prefisso Italia opzionale
# [\s.-]?     - Separatore opzionale
# (?:3\d{2}|0\d{1,4}) - Cellulare (3xx) o fisso (0xx)
# \d{6,8}     - Resto del numero

# Esempi validi:
# +39 333 1234567
# 02 12345678
# 333.123.4567

# Pattern internazionale generico
^\+?[\d\s.-]{10,15}$

Pattern 4: Data

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

# Spiegazione:
# (0[1-9]|[12]\d|3[01]) - Giorno 01-31
# \/                     - Slash
# (0[1-9]|1[0-2])       - Mese 01-12
# \/                     - Slash
# \d{4}                  - Anno 4 cifre

# Formato ISO (YYYY-MM-DD)
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

# JavaScript con gruppi
const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
const match = '25/12/2024'.match(dateRegex);
// match[1] = '25' (giorno)
// match[2] = '12' (mese)
// match[3] = '2024' (anno)

Pattern 5: Codice Fiscale Italiano

# Pattern completo
^[A-Z]{6}\d{2}[A-EHLMPR-T]\d{2}[A-Z]\d{3}[A-Z]$

# Spiegazione:
# [A-Z]{6}    - 6 lettere (cognome + nome)
# \d{2}       - 2 cifre (anno)
# [A-EHLMPR-T] - Lettera mese
# \d{2}       - 2 cifre (giorno)
# [A-Z]       - Codice comune (lettera)
# \d{3}       - Codice comune (cifre)
# [A-Z]       - Carattere di controllo

# JavaScript (case insensitive)
const cfRegex = /^[A-Z]{6}\d{2}[A-EHLMPR-T]\d{2}[A-Z]\d{3}[A-Z]$/i;

# Match:
# RSSMRA85M01H501W ✓
# INVALID ✗

Pattern 6: Password Sicura

# Almeno 8 caratteri, maiuscola, minuscola, numero, speciale
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

# Spiegazione lookahead:
# (?=.*[a-z]) - Contiene minuscola
# (?=.*[A-Z]) - Contiene maiuscola
# (?=.*\d)    - Contiene numero
# (?=.*[@$!%*?&]) - Contiene carattere speciale
# {8,}        - Minimo 8 caratteri

# JavaScript
const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

# Match:
# MyP@ssw0rd ✓
# password123 ✗ (no maiuscola, no speciale)

Pattern 7: Indirizzo IP

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

# Spiegazione:
# 25[0-5]     - 250-255
# 2[0-4]\d    - 200-249
# [01]?\d\d?  - 0-199
# (?:...\.){3} - Ripeti 3 volte con punto

# Versione semplificata (meno precisa ma più leggibile)
^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$

# JavaScript
const ipRegex = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;

# Match:
# 192.168.1.1 ✓
# 10.0.0.1 ✓
# 999.999.999.999 ✗

Pattern 8: Tag HTML

# Match tag con contenuto
<(\w+)[^>]*>(.*?)<\/\1>

# Spiegazione:
# <(\w+)      - Tag apertura, cattura nome
# [^>]*       - Attributi (tutto tranne >)
# >           - Fine tag apertura
# (.*?)       - Contenuto (lazy)
# <\/\1>      - Tag chiusura con backreference

# JavaScript
const htmlRegex = /<(\w+)[^>]*>(.*?)<\/\1>/g;
const html = '
Hello
';
const match = html.match(htmlRegex);
// ["
Hello
"]

# Estrai tutti i link
const linkRegex = /]*>(.*?)<\/a>/gi;

Pattern 9: Numero con Formattazione

# Numero con separatori migliaia
^-?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d+)?$

# Valuta con simbolo
^[€$£]?\s?-?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?$

# JavaScript - rimuovi formattazione
function parseNumber(str) {
  // Determina separatore decimale
  const lastDot = str.lastIndexOf('.');
  const lastComma = str.lastIndexOf(',');

  if (lastComma > lastDot) {
    // Formato italiano: 1.234,56
    return parseFloat(str.replace(/\./g, '').replace(',', '.'));
  } else {
    // Formato inglese: 1,234.56
    return parseFloat(str.replace(/,/g, ''));
  }
}

# Match:
# 1,234.56 ✓
# 1.234,56 ✓
# €1.234,56 ✓

Pattern 10: Spazi e Formattazione

# Rimuovi spazi multipli
/\s+/g → ' '

# Trim spazi
/^\s+|\s+$/g → ''

# Normalizza newline
/\r\n|\r/g → '\n'

# JavaScript
function normalizeText(text) {
  return text
    .trim()                    // Rimuovi spazi inizio/fine
    .replace(/\s+/g, ' ')      // Spazi multipli → singolo
    .replace(/\r\n|\r/g, '\n'); // Normalizza newline
}

# Rimuovi tag HTML
const stripHtml = /<[^>]+>/g;
'
Hello
'.replace(stripHtml, '');  // "Hello"

Utilizzo in JavaScript

// Metodi principali
const regex = /pattern/flags;

// test() - restituisce boolean
regex.test('string');  // true/false

// match() - restituisce array di match
'string'.match(regex);  // ['match1', 'match2']

// replace() - sostituisce
'string'.replace(regex, 'replacement');

// split() - divide
'a,b,c'.split(/,/);  // ['a', 'b', 'c']

// exec() - restituisce dettagli
regex.exec('string');  // { 0: 'match', index: 0, groups: {} }

// Flags
/pattern/g  // global: tutti i match
/pattern/i  // case insensitive
/pattern/m  // multiline
/pattern/s  // dotall (. include newline)

Strumenti per Testing

Per testare e debuggare le regex:

• Regex Tester - Testa pattern con evidenziazione
• Text Tools - Manipolazione testo
• JSON Formatter - Formatta output

Best Practices

• Testa sempre: Usa regex tester online prima del codice
• Documenta: Le regex complesse necessitano commenti
• Non over-engineer: A volte split/indexOf è più chiaro
• Considera performance: Regex complesse possono essere lente
• Escape input utente: Mai costruire regex da input non validato

Conclusione

Le espressioni regolari sono uno strumento potente che ogni sviluppatore dovrebbe padroneggiare. Questi 10 pattern coprono la maggior parte dei casi d'uso comuni. Ricorda: inizia semplice e aggiungi complessità solo quando necessario.

Per altri strumenti utili, esplora i nostri tool online gratuiti. Per una reference completa, consulta MDN Regular Expressions.