1. Apri il RegEx Tester
2. Pattern RegEx: Inserisci la tua espressione regolare (es. `/\d{3}-\d{4}/`)
3. Flags: Seleziona opzioni:
   • g (global): Trova tutte le occorrenze
   • i (case-insensitive): Ignora maiuscole/minuscole
   • m (multiline): `^` e `$` matchano inizio/fine riga
   • s (dotAll): `.` matcha anche newline
   • u (unicode): Supporto pieno Unicode
4. Test String: Inserisci il testo da testare
5. Vedi risultati in tempo reale con evidenziazione match

Funzionalità Avanzate

• Match Groups: Visualizza gruppi di cattura `(...)` estratti
• Replace Mode: Testa sostituzioni con `$1`, `$2` per gruppi
• Pattern Library: Template predefiniti per casi comuni (email, URL, telefono, codice fiscale)
• Debug Mode: Visualizza step-by-step come la regex matcha il testo
• Performance: Warning se regex è inefficiente (ReDoS risk)

Esempio Pratico: Validare Email

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

// 2. Flags: nessuno (match case-sensitive)

// 3. Test string
mario.rossi@example.com
MARIO@EXAMPLE.IT
invalid-email
test@subdomain.example.co.uk

// 4. Risultati
✅ mario.rossi@example.com (match completo)
✅ MARIO@EXAMPLE.IT (match completo)
❌ invalid-email (no match)
✅ test@subdomain.example.co.uk (match completo)

Esempi di Codice

JavaScript

// Test regex
const regex = /^3\d{2}\s?\d{6,7}$/
regex.test('333 1234567') // true
regex.test('02 12345') // false

// Estrazione con match()
const text = "Email: test@example.com, info@test.it"
const emails = text.match(/[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/gi)
console.log(emails) // ["test@example.com", "info@test.it"]

// Replace con gruppi di cattura
const data = "25/12/2024"
const formatted = data.replace(/(\d{2})\/(\d{2})\/(\d{4})/, '$3-$2-$1')
console.log(formatted) // "2024-12-25"

// Validazione form in React
function validateEmail(email) {
  const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
  return regex.test(email)
}

// Estrazione gruppi con exec()
const regex = /(\d{2})\/(\d{2})\/(\d{4})/
const match = regex.exec("Data: 25/12/2024")
if (match) {
  console.log(`Giorno: ${match[1]}, Mese: ${match[2]}, Anno: ${match[3]}`)
}

Python

import re

# Test regex
pattern = r'^3\d{2}\s?\d{6,7}$'
re.match(pattern, '333 1234567')  # Match object
re.match(pattern, '02 12345')     # None

# Estrazione
text = "Email: test@example.com, info@test.it"
emails = re.findall(r'[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}', text, re.IGNORECASE)
print(emails)  # ['test@example.com', 'info@test.it']

# Replace con gruppi
data = "25/12/2024"
formatted = re.sub(r'(\d{2})/(\d{2})/(\d{4})', r'\3-\2-\1', data)
print(formatted)  # "2024-12-25"

# Validazione codice fiscale
def validate_cf(cf):
    pattern = r'^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$'
    return bool(re.match(pattern, cf.upper()))

# Parsing log con gruppi nominati
log = '192.168.1.1 - - [10/Dec/2024:13:55:36] "GET /api/users HTTP/1.1" 200'
pattern = r'(?P\S+).*\[(?P[\w:/]+).*\] "(?P\w+) (?P\S+).*" (?P\d{3})'
match = re.search(pattern, log)
print(match.groupdict())
# {'ip': '192.168.1.1', 'date': '10/Dec/2024:13:55:36', 'method': 'GET', 'path': '/api/users', 'status': '200'}

PHP

<?php
// Test regex
$pattern = '/^3\d{2}\s?\d{6,7}$/';
preg_match($pattern, '333 1234567');  // 1 (true)
preg_match($pattern, '02 12345');     // 0 (false)

// Estrazione
$text = "Email: test@example.com, info@test.it";
preg_match_all('/[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i', $text, $matches);
print_r($matches[0]);  // Array(['test@example.com', 'info@test.it'])

// Replace
$data = "25/12/2024";
$formatted = preg_replace('/(\d{2})\/(\d{2})\/(\d{4})/', '$3-$2-$1', $data);
echo $formatted;  // "2024-12-25"

// Validazione Partita IVA
function validatePIVA($piva) {
    return preg_match('/^IT\d{11}$/', $piva);
}

// Sanitizzazione input (rimuovere caratteri non alfanumerici)
$input = "Hello, World! 123";
$clean = preg_replace('/[^a-zA-Z0-9\s]/', '', $input);
echo $clean;  // "Hello World 123"
?>

Pattern RegEx Comuni per l'Italia

Confronto RegEx Tester

Quando Usare THEJORD RegEx Tester

• ✅ Privacy-first: Nessun dato inviato a server esterni (tutto in locale)
• ✅ Pattern italiani: Library con regex per codice fiscale, P.IVA, CAP, IBAN
• ✅ Fast: Nessun loading, elaborazione istantanea
• ✅ Gratuito: Nessun limite di utilizzo o registrazione
• ✅ Multi-language: Supporto JavaScript, Python, PHP, Java syntax

Best Practices e Performance

⚠️ Evitare Catastrophic Backtracking (ReDoS)

Alcune regex possono causare esecuzione esponenziale su input specifici:

// ❌ PERICOLOSO - ReDoS vulnerability
/(a+)+b/
/(\w+\s?)*$/

// ✅ SICURO - Quantificatori non annidati
/a+b/
/[\w\s]+$/

Regola: Evita quantificatori annidati `(a+)+`, `(a*)*`, `(a+)*`.

✅ Ottimizzare le Regex

• Usa ancore: `^` e `$` limitano il matching
• Classi specifiche: `\d` invece di `[0-9]`, `\w` invece di `[a-zA-Z0-9_]`
• Gruppi non-cattura: `(?:...)` invece di `(...)` se non serve estrarre
• Alternanza efficiente: `(jpg|png|gif)` invece di `(jpg)|(png)|(gif)`

🧪 Testare Edge Cases

Verifica sempre con input limite:

• Stringa vuota: `""`
• Un solo carattere: `"a"`
• Caratteri speciali: `"!@#$%"`
• Unicode/emoji: `"hello 👋"`
• Molto lungo: 10.000+ caratteri
• Newline e tab: `"hello\nworld\t"`

Domande Frequenti (FAQ)

Qual è la differenza tra /g e senza flag g?

Senza `g`, la regex si ferma al primo match. Con `g` (global), trova tutte le occorrenze nel testo.

const text = "cat bat rat"
text.match(/at/)   // ["at"] (solo primo match)
text.match(/at/g)  // ["at", "at", "at"] (tutti i match)

Come faccio a matchare un carattere speciale come . o *?

Usa il backslash `\` per fare escape dei metacaratteri:

/\./ → matcha il punto letterale "."
/\*/ → matcha asterisco "*"
/\+/ → matcha più "+"
/\(/ → matcha parentesi tonda "("

Regex per validare password sicura?

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

Spiegazione: Usa lookahead positivo `(?=...)` per verificare ogni condizione senza consumare caratteri.

Come estrarre contenuto tra tag HTML?

⚠️ Attenzione: Le regex NON sono adatte per parsing HTML complesso. Per HTML usa un parser (DOMParser, Cheerio, BeautifulSoup).

Per casi semplici:

// Estrarre testo in 

/
(.*?)<\/p>/gs

// Estrarre href da 
/

Input: "
hello
world
"

/
.*<\/p>/  → match: "
hello
world
" (tutto)
/
.*?<\/p>/ → match: "
hello
" (solo primo tag)

/hello/.test("HELLO")   // false
/hello/i.test("HELLO")  // true