La nostra calcolatrice online per regex ti consente di scrivere e testare espressioni regolari in tempo reale con l'evidenziazione istantanea delle corrispondenze. Visualizza tutte le corrispondenze, i gruppi di cattura e gli indici di corrispondenza mentre digiti. Supporta tutti i flag regex di JavaScript (global, case-insensitive, multiline, dotAll, unicode, sticky). Include una modalità di sostituzione per testare la ricerca e sostituzione, oltre a un completo cheat sheet di regex per una consultazione rapida.
No matches yet
Digita il tuo pattern regex nel campo del pattern. Gli errori di sintassi vengono evidenziati in tempo reale.
Incolla o digita il testo da verificare. Le corrispondenze vengono evidenziate all'istante.
Abilita flag come global (g), case-insensitive (i) o multiline (m) per modificare il comportamento della ricerca.
Visualizza tutte le corrispondenze, i gruppi di cattura e le posizioni delle corrispondenze. Usa la modalità di sostituzione per testare cerca e sostituisci.
Le espressioni regolari sono modelli usati per trovare combinazioni di caratteri nelle stringhe. Il motore regex analizza la stringa di test da sinistra a destra, tentando di trovare una corrispondenza in ogni posizione. I flag modificano il comportamento della ricerca: 'g' trova tutte le corrispondenze, 'i' ignora maiuscole/minuscole, 'm' fa sì che ^ e $ corrispondano ai confini delle righe.
new RegExp(pattern, flags).exec(testString)
Usa il flag 'g' per trovare tutte le corrispondenze, non solo la prima
Effettua l'escape dei caratteri speciali con il backslash: \. \( \) \[ \] \{ \} \+ \* \?
Usa (?:...) per gruppi non di cattura quando non ti serve il valore della corrispondenza
\d = cifra, \w = carattere di parola, \s = spazio vuoto, \b = confine di parola
Usa .+? (pigro) invece di .+ (avido) per catturare meno testo possibile
Il flag 'm' fa sì che ^ e $ corrispondano all'inizio/fine di ogni riga, non solo della stringa
Testa casi limite: stringhe vuote, caratteri speciali e input molto lunghi
Il nostro tester di regex gratuito ti consente di creare, testare e correggere espressioni regolari con evidenziazione delle corrispondenze in tempo reale. Visualizza corrispondenze, gruppi di cattura e risultati di sostituzione istantaneamente mentre digiti. Funziona con la sintassi regex di JavaScript.
Digita il tuo modello regex e guarda le corrispondenze evidenziate in tempo reale. Il nostro tester di regex supporta tutti i flag JavaScript inclusi:
Ogni corrispondenza è evidenziata con i gruppi di cattura visualizzati separatamente per un facile debug.
Crea modelli regex complessi con il nostro strumento interattivo. Guarda esattamente a cosa corrisponde il tuo modello e perché.
I gruppi di cattura sono numerati e visualizzati, facilitando la creazione di modelli per:
Riferimento rapido per la sintassi regex comune:
Tutto ciò di cui hai bisogno per creare pattern regex direttamente accanto al tester.
Un'espressione regolare (regex) è una sequenza di caratteri che definisce un pattern di ricerca per trovare corrispondenze nel testo. Il motore regex legge il pattern e analizza la stringa di input da sinistra a destra, tentando una corrispondenza in ogni posizione fino a quando non ha successso o esaurisce la stringa.
Secondo la documentazione di MDN Web Docs, le espressioni regolari in JavaScript sono oggetti creati tramite un letterale (/pattern/flags) o il costruttore RegExp. La sintassi formale e la semantica di corrispondenza sono definite nella specifica del linguaggio ECMAScript gestita da TC39, mentre la teoria più ampia risale ai linguaggi regolari nella teoria dei linguaggi formali.
La maggior parte dei motori moderni, inclusi quelli in Chrome (V8), Node.js e .NET, implementa matcher a backtracking che supportano funzionalità come i riferimenti all'indietro (backreferences) e il lookaround oltre i semplici automi a stati finiti.
Le classi di caratteri e i quantificatori sono i blocchi fondamentali di qualsiasi pattern regex. Una classe di caratteri come [a-z] corrisponde a qualsiasi singolo carattere nell'insieme, mentre le classi abbreviate come \d (cifra), \w (carattere di parola) e \s (spazio vuoto) sono definite nella specifica ECMAScript e documentate su MDN Web Docs.
I quantificatori controllano la ripetizione:
Combinali per creare pattern precisi, ad esempio \d{3}-\d{4} per un frammento di numero telefonico. Le classi negate come [^0-9] corrispondono a qualsiasi cosa tranne i caratteri elencati, offrendoti un controllo di precisione su quale testo il tuo pattern accetta.
Gli ancoraggi e i delimitatori corrispondono a posizioni anziché a caratteri, consentendoti di asserire dove deve verificarsi una corrispondenza senza consumare testo. Il cursore ^ si ancora all'inizio della stringa (o della linea con il flag multiline), $ si ancora alla fine e \b segna un confine di parola tra un carattere di parola e uno non di parola, come documentato da MDN Web Docs e dalla specifica ECMAScript.
Le asserzioni di lookaround estendono questa idea: il lookahead (?=...) e il lookahead negativo (?!...) controllano ciò che segue, mentre il lookbehind (?<=...) e (?
Queste asserzioni a larghezza zero sono essenziali per le regole delle password, la validazione e la corrispondenza di token solo in contesti specifici.
I gruppi di cattura con nome consentono di etichettare una sottostringa catturata per pattern più chiari e gestibili. Introdotti in JavaScript in ECMAScript 2018 e documentati su MDN Web Docs, la sintassi (?
I riferimenti all'indietro riutilizzano un valore precedentemente catturato più avanti nello stesso pattern: \1 si riferisce al primo gruppo numerato e \k['\"]).*?\k
corrisponde a una stringa racchiusa tra virgolette che si chiude con lo stesso carattere di virgoletta con cui è iniziata.
I gruppi con nome migliorano la leggibilità rispetto agli indici posizionali, specialmente in pattern complessi per l'analisi di date, URL o righe di log strutturate.
Le regex sono ampiamente utilizzate per validare ed estrarre email e URL, sebbene la conformità completa alle specifiche RFC sia ingannevolmente difficile. Il formato dell'email è definito nella RFC 5322 e la sua grammatica degli indirizzi è sufficientemente complessa che nessuna regex breve la cattura perfettamente; MDN Web Docs e la specifica HTML del WHATWG raccomandano un pattern pragmatico per il campo input type=email piuttosto che un parser RFC 5322 rigido.
Gli URL seguono la sintassi generica nella RFC 3986. Per la maggior parte delle applicazioni, un pattern permissivo che rileva errori evidenti oltre a una reale verifica di consegna o richiesta è più robusto di un'espressione esaustiva.
Usa questo tester per verificare il tuo pattern rispetto a campioni validi e non validi prima di metterlo in produzione, evitando falsi negativi che potrebbero rifiutare input legittimi degli utenti.
Le regex sono sicure per il confronto ma possono creare rischi di negazione del servizio se i pattern sono scritti senza attenzione. Il Regular Expression Denial of Service (ReDoS), documentato da OWASP, si verifica quando un motore a backtracking incontra un backtracking catastrofico su input predisposti, causando tempi esponenziali e bloccando il processo. Il fattore scatenante classico sono i quantificatori annidati o sovrapposti su pattern ambigui, come (a+)+$ contro una lunga stringa di 'a' seguita da un carattere non corrispondente.
OWASP raccomanda:
Quando esegui regex su testo controllato da un utente malintenzionato, preferisci pattern di libreria testati e verifica i casi peggiori in questo strumento prima del deployment.
I flag delle regex condividono concetti tra i vari linguaggi ma differiscono nella sintassi e nelle funzionalità disponibili. In JavaScript, i flag vengono aggiunti al letterale (/pattern/gi) o passati come secondo argomento del costruttore RegExp, con g, i, m, s, u e y definiti nella specifica ECMAScript e spiegati su MDN Web Docs.
Il modulo re di Python utilizza flag in-line come re.IGNORECASE o prefissi (?i) e non possiede il flag sticky. PCRE e i motori compatibili con Perl utilizzati da PHP e molti strumenti supportano modificatori simili oltre a funzionalità avanzate.
Questo tester utilizza il motore JavaScript, quindi i pattern si comportano esattamente come faranno nei browser e in Node.js. Quando si trasporta un pattern in un altro linguaggio, bisogna riverificare il comportamento dei quantificatori, la gestione di Unicode e il supporto del lookbehind, poiché variano tra le diverse implementazioni.
Gli errori più comuni nelle regex riguardano caratteri speciali non convalidati da escape, quantificatori avidi e flag dimenticati. I metacaratteri come . ( ) [ ] { } + * ? ^ $ | \ hanno un significato speciale e devono essere preceduti da un backslash per corrispondere letteralmente, secondo la specifica ECMAScript e MDN Web Docs; un . nudo corrisponde a qualsiasi carattere, non a un punto.
I quantificatori avidi come .+ esagerano e catturano più del dovuto, quindi usa le versioni pigre .+? quando fai il match tra delimitatori. Dimenticare il flag g restituisce solo la prima corrispondenza e omettere gli ancoreggi permette ai pattern di trovare sottostringhe non volute.
Altre insidie includono l'ignorare Unicode con il flag u e dare per scontato che il lookbehind funzioni ovunque. Testa i casi limite come stringhe vuote, interruzioni di linea e input ostili in questo strumento prima di fare affidamento su qualsiasi pattern.
Data sourced from trusted institutions
All formulas verified against official standards.