# Pattern italiani pronti per CF, P.IVA, IBAN, telefono

> Regex tester online JavaScript con highlight, capture groups, flag (gimsuy). Pattern library: email, URL, IP, CF italiano, P.IVA, IBAN, data ISO.

Strumento gratuito nel browser (nessun upload): https://www.mauriziofonte.it/strumenti/regex-tester

Tester di **regex JavaScript**: incolla un pattern (con flag `gimsuy`) e una stringa di test, ottieni **highlight** dei match, **capture groups**, **match count**. Pattern library categorizzata con regex pronte per: email, URL, IP, MAC address, telefono italiano, codice fiscale, partita IVA, IBAN, data ISO, slug, hex color.

## Come usare il regex tester

1. **Inserisci pattern e flag** - Pattern: senza delimitatori (no `/.../`), solo il body. Flag: `g` (global, tutti i match), `i` (case-insensitive), `m` (multiline, ^$ matchano start/end di riga), `s` (dotAll. matcha anche newline), `u` (unicode), `y` (sticky).
2. **Incolla la stringa di test** - Testo libero, anche multi-riga. Il tester usa il motore `RegExp` nativo del browser (V8 / SpiderMonkey / JavaScriptCore), quindi sintassi e perf sono quelli del JS standard.
3. **Leggi i risultati** - Output: stringa originale con i match evidenziati in giallo, statistiche (match totali, capture groups), lista match con index. Per i capture groups: ogni match mostra anche i gruppi catturati con loro indice.
4. **Pattern library** - Bottone 'Pattern library' apre una lista categorizzata di pattern pronti: email RFC-friendly, URL HTTP/HTTPS, IPv4/IPv6, MAC address, telefono italiano (fisso e mobile), codice fiscale italiano (16 char), partita IVA (11 cifre), IBAN, data ISO 8601, slug URL-safe. Click per caricarli nel pattern field.

## Regex JavaScript: perché un tester dedicato

**Differenze fra dialetti regex.** Le regex di JavaScript sono ECMAScript-compliant ma differiscono da quelle di PCRE (PHP, Perl), POSIX (grep, sed).NET, Python `re`. Esempio: i lookbehind variable-length sono supportati in JS dal 2018 (ECMAScript 2018), assenti in vecchi browser. Atomic groups `(?>...)` assenti in JS (presenti in PCRE/Perl). Recursive patterns assenti in JS. Per regex testing affidabile su pattern complessi, usa il tester della stessa famiglia del runtime di destinazione.

**Cosa offre questo tool.** Tester con **RegExp nativo** del browser, quindi rappresenta esattamente cosa accade nel codice JS in produzione. Highlight match in giallo per visualizzazione. Capture groups numerati e named (sintassi `(?<name>...)`). Match index. Pattern library di 12+ regex italiane comuni (CF, P.IVA, IBAN, telefono italiano) pronte per uso.

**Caveat di performance.** Il tool non fa backtracking detection. Pattern catastrofici come `(a+)+` su input lungo bloccano il tab del browser. Se il tester sembra freezato: chiudi il tab. Per audit di catastrophic backtracking: [redos-checker](https://devina.io/redos-checker) o tools dedicati. In production, usa [RE2](https://github.com/google/re2) (linear-time, no backtracking) per regex su input untrusted.

## Glossario

- **Regex**: Regular expression: pattern formale per matching di stringhe. Inventato negli anni '60 (Stephen Kleene). Implementazioni moderne: PCRE (Perl Compatible), ECMAScript (JavaScript), POSIX (grep/sed), RE2 (Google, linear-time).
- **Capture group**: Sotto-espressione fra parentesi `(...)` che cattura una sotto-stringa. Numerata da 1 (gruppo 0 = match completo). Named group: `(?<name>...)`. Non-capturing: `(?:...)`.
- **Lookahead / Lookbehind**: Asserzioni di posizione. `(?=...)` positive lookahead (match seguito da). `(?!...)` negative lookahead. `(?<=...)` lookbehind. Variabili in lunghezza supportati in JS dal 2018.
- **Backtracking**: Comportamento del motore regex quando un match parziale fallisce: torna indietro e prova alternative. Pattern come `(a+)+` su input `aaaaab` hanno complessità esponenziale (catastrophic backtracking).
- **RE2**: Motore regex di Google con complessità linear-time. Niente backtracking, niente lookbehind, niente backreferences. Sicuro per regex su input untrusted (no DoS via catastrophic backtracking). Usato da Google, Cloudflare, GitHub Code Search.
- **Sticky flag (y)**: Flag JS che fa ripartire il match dalla posizione `lastIndex` esatta (no advancing). Utile per parser tokenizzanti. Diverso da `g` che permette di skippare caratteri non matchabili.

## Domande frequenti regex

### Come uso una regex con flag in JS production?

Due sintassi: literal `/pattern/flags` oppure constructor `new RegExp('pattern', 'flags')`. Literal è compilato a parse-time (niente runtime overhead). Constructor è utile per pattern dinamici (es. user input). Caveat: nel constructor, le sequenze di escape vanno raddoppiate (`'\\d'` per `\d`).

### La mia regex è lenta su input lungo: cosa fare?

Possibile catastrophic backtracking. Tipici offender: `(a+)+`, `(.*)*`, alternazioni con prefisso comune. Tre strategie: (1) refactor verso pattern lineare (es. `a+` invece di `(a+)+`); (2) atomic groups o possessive quantifier (NON disponibili in JS, solo PCRE); (3) usa RE2 lato backend per input untrusted (Node.js: `re2` npm package; Go: `regexp` standard library).

### Differenze regex JS vs PHP/Python?

JS ECMAScript: niente atomic groups, niente recursive, niente possessive quantifier, niente backreference in lookbehind. PHP PCRE / Python re: tutti supportati. Esempio: pattern `(?P<name>...)` Python NON funziona in JS (sintassi Python diversa). JS usa `(?<name>...)` ES2018+.

### Email regex 100% RFC compliant esiste?

Tecnicamente: [RFC 5322](https://www.rfc-editor.org/rfc/rfc5322) compliant è una regex di ~6.000 caratteri. In pratica: nessuno la usa. Pattern pragmatico (in libreria): `^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$` copre il 99.99% dei casi reali. Per validazione rigorosa: invia email di conferma + click link.

### Pattern italiano per CF: cosa controlla davvero?

Solo il **formato** (16 caratteri alfanumerici nel pattern atteso). NON il CIN (carattere di controllo). Per validazione completa con CIN: usa il [validatore anagrafica](/strumenti/validatore-anagrafica-italiana) di questo sito. Una regex non può calcolare la somma modulo 26 del CIN.

### Come testare regex con multiline input?

Flag `m` abilita `^` e `$` a matchare a inizio/fine di ogni riga (non solo dell'intera stringa). Senza `m`, `^` matcha solo l'inizio dell'input completo. Esempio: `^abc` con `m` matcha 'abc' a ogni inizio riga.

### Posso usare unicode property classes (\p{...})?

Sì, con flag `u` (Unicode) abilitato. Sintassi: `\p{Letter}` matcha qualunque lettera Unicode (incluso accenti italiani, cirillico, ecc). `\P{Letter}` NON-lettera. Supportato in tutti i browser moderni (2020+).

---
Uno strumento di Maurizio Fonte, senior backend engineer. Tutti gli strumenti: https://www.mauriziofonte.it/strumenti/