Tester di Espressioni Regolari

Le espressioni regolari (regex) sono pattern per la corrispondenza di testo. Questo strumento analizza la sintassi regex, spiega i componenti del pattern e fornisce un'area di test per provare le corrispondenze su testo di esempio. Supporta i formati regex JavaScript, PCRE e Python.

Specifiche

• ECMAScript RegExp
• PCRE2 Syntax
• Python re module

Casi d'uso comuni

• Debug del motivo per cui un regex non corrisponde al testo previsto
• Imparare la sintassi regex attraverso le spiegazioni
• Testare i pattern prima di aggiungerli al codice
• Validare i pattern di input per i campi dei form
• Estrarre dati da testo strutturato (log, CSV, HTML)

Funzionalità

• Rilevamento del formato regex (JavaScript /pattern/flags, PCRE #pattern#, Python r"pattern")
• Spiegazione dei componenti del pattern in linguaggio semplice
• Test su testo di esempio con evidenziazione delle corrispondenze
• Modalita corrispondenza singola o trova tutte le corrispondenze
• Visualizzazione dei gruppi di cattura e del loro contenuto
• Visualizzazione dei gruppi di cattura denominati
• Visualizzazione delle posizioni e degli indici delle corrispondenze
• Visualizzazione del tempo di esecuzione regex
• Badge delle funzionalita del pattern (ancoraggi, quantificatori, ecc.)
• Avvisi sul pattern
• Libreria di pattern comuni (email, URL, telefono, ecc.)

Esempi

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

/https?:\/\/[^\s]+/g

/(\d{4})-(\d{2})-(\d{2})/

Suggerimenti

• Usa tester online per il debug di pattern complessi prima della produzione.
• Esegui l'escape dei caratteri speciali (. ^ $ * + ? { } [ ] \ | ( )) con il backslash.
• I gruppi di cattura denominati (?<name>...) rendono le corrispondenze piu leggibili.
• Il flag g trova tutte le corrispondenze; senza di esso viene restituita solo la prima corrispondenza.
• Attenzione ai quantificatori avidi (* +); usa quelli pigri (*? +?) quando appropriato.

Approfondimenti Tester di Espressioni Regolari

Le espressioni regolari (regex) sono un linguaggio di corrispondenza dei pattern utilizzato in praticamente ogni linguaggio di programmazione, editor di testo e strumento da riga di comando. Un regex definisce un pattern di ricerca usando una combinazione di caratteri letterali e metacaratteri che corrispondono a classi di stringhe. Sono essenziali per la validazione degli input, l'estrazione di testo, le operazioni di ricerca e sostituzione e l'analisi dei log.

La sintassi di base include classi di caratteri ([a-z], \\d, \\w, \\s), quantificatori (*, +, ?, {n,m}), ancoraggi (^, $, \\b), alternanza (|) e raggruppamento con parentesi. I gruppi catturati estraggono le sottostringhe corrispondenti e abilitano i riferimenti all'indietro. I lookahead (?=...) e i lookbehind (?<=...) corrispondono alle posizioni senza consumare caratteri, consentendo asserzioni complesse sul contesto circostante.

Il regex JavaScript ha il suo dialetto con flag specifici: g (globale), i (case-insensitive), m (multilinea), s (dotAll), u (Unicode) e y (sticky). Il flag u e sempre piu importante per gestire correttamente il testo Unicode, poiche senza di esso i pattern potrebbero non corrispondere correttamente ai caratteri multibyte. I gruppi di cattura denominati (?<name>...) migliorano la leggibilita rispetto ai gruppi numerati.

I compiti regex comuni includono la validazione email, il parsing degli URL, l'estrazione di dati da testo strutturato (file di log, CSV) e la sostituzione di pattern nel refactoring del codice. Tuttavia, i regex hanno dei limiti — non possono analizzare strutture annidate come HTML o JSON (usa un parser appropriato), e i pattern eccessivamente complessi diventano illeggibili e difficili da manutenere. La battuta "ora hai due problemi" riflette sfide reali di manutenzione con regex complessi.

L'HTML e un linguaggio context-free con strutture annidate che le espressioni regolari fondamentalmente non possono gestire. Un regex non puo corrispondere correttamente ai tag di apertura e chiusura con profondita di annidamento arbitraria. I casi semplici possono sembrare funzionare ma falliscono nei casi limite che coinvolgono tag annidati, attributi contenenti > o commenti. Per l'elaborazione HTML, usa un parser DOM come DOMParser nel browser, cheerio per Node.js o BeautifulSoup per Python.

La differenza tra .* (avido) e .*? (pigro) e significativa per il comportamento di corrispondenza. L'avido .* corrisponde al maggior numero possibile di caratteri, poi torna indietro se necessario. Il pigro .*? corrisponde al minor numero possibile di caratteri. In una stringa come "<b>uno</b><b>due</b>", il pattern avido <b>.*</b> corrisponde all'intera stringa, mentre il pattern pigro <b>.*?</b> corrisponde solo al primo "<b>uno</b>". Scegliere la modalita sbagliata e una delle cause piu comuni di comportamento regex inaspettato.

In JavaScript, il flag u (/pattern/u) abilita la corrispondenza Unicode-aware. Senza di esso, il metacarattere . non corrisponde ai caratteri al di fuori del Basic Multilingual Plane (come le emoji), e \\w corrisponde solo ai caratteri parola ASCII. Il flag u fa si che i quantificatori e le classi di caratteri gestiscano correttamente le coppie surrogate e abilita gli escape delle proprieta Unicode come \\p{Letter}. I lookahead (?=...) e i lookbehind (?<=...) sono asserzioni a larghezza zero che controllano i pattern in una posizione senza includerli nella corrispondenza. Il lookahead positivo (?=...) asserisce cosa deve seguire, mentre il lookahead negativo (?!...) asserisce cosa non deve seguire. Ad esempio, \\d+(?= dollars) corrisponde ai numeri seguiti da " dollars" ma cattura solo il numero stesso. I lookbehind funzionano allo stesso modo ma controllano il testo precedente.