Vai al contenuto

Banco di prova per espressioni regolari

Regex Tester

Prova un’espressione regolare su un testo di esempio, evidenziando dal vivo le corrispondenze ed elencando i gruppi di cattura.

Esegue un’espressione regolare su un testo di prova e mostra ogni corrispondenza con i suoi offset, i suoi gruppi di cattura e la sostituzione che produrrebbe. È il motore del browser stesso, quindi quello che succede qui è quello che succederà nel proprio JavaScript.

🔒 Funziona interamente nel tuo browserregextestpattern
Vista

Pattern

//g

può corrispondere ovunque nella stringa, 2 gruppi di cattura.

Prova su

Sono elencate tutte le corrispondenze. Senza il flag `g`, `String.replace` usa solo la prima.

0 corrispondenze

Tempo

0,0 ms

ask@example.com, 문의@example.co.kr and no-reply+tag@mail.example.org

Sostituisci

`$1`, `$<name>`, `$&`, `` $` ``, `$'` e `$$` si espandono tutti, esattamente come li espande `String.replace`.

Come si usa

  1. Scrivere il pattern e impostare i flag

    I pulsanti dei flag sono i sei che contano: global, ignore case, multiline, dotAll, unicode e sticky. Il letterale in alto è quello che si incollerebbe nel codice.

  2. Incollare un testo che si ha davvero

    Le corrispondenze vengono evidenziate sul posto, a colori alternati perché quelle adiacenti restino distinguibili, ed elencate in una tabella con il valore di ogni gruppo — compresi i gruppi che non hanno partecipato.

  3. Provare la sostituzione

    `$1`, `$<name>`, `$&`, `` $` ``, `$'` e `$$` si espandono esattamente come li espande `String.replace`, quindi l’anteprima è l’output vero.

Domande frequenti

Perché la pagina avverte che manca il flag `g`?

Perché l’elenco mostra ogni corrispondenza, mentre senza `g` il codice non lo fa. `String.replace` cambia solo la prima, e `matchAll` solleva direttamente un errore. È la differenza fra quello che si vede qui e quello che fa il programma.

È lo stesso motore di Python o di PCRE?

No: è quello di JavaScript. Lookbehind, gruppi denominati e `\p{…}` qui sono supportati, ma gruppi atomici, quantificatori possessivi, ricorsione e gruppi di flag inline no, e il comportamento delle classi di caratteri in alcuni punti è diverso. Un pattern che funziona qui può comunque fallire altrove.

Il mio pattern blocca la pagina.

Non dovrebbe: il confronto gira in un worker proprio perché un pattern con backtracking catastrofico non si può interrompere in nessun altro modo. Se ci mette troppo, l’esecuzione viene terminata e segnalata, il che è anche un segnale utile: un pattern che si comporta così qui si comporterà così anche sul server.

Perché `.` non corrisponde al mio ritorno a capo?

Perché è a questo che serve `s` (dotAll). Senza, `.` corrisponde a tutto tranne che a un terminatore di riga — e `m` (multiline) è un’altra cosa ancora: cambia il significato di `^` e `$`, non quello che `.` trova.

Può ricevere da

Dopo

Questi accettano ciò che produce questo strumento, così il risultato può passare direttamente.