Pular para o conteúdo

Testador de regex

Regex Tester

Testa uma expressão regular contra um texto de exemplo com destaque ao vivo das ocorrências e lista dos grupos de captura.

Executa uma expressão regular contra um texto de exemplo e mostra cada correspondência com seus offsets, seus grupos de captura e a substituição que produziria. É o motor do próprio navegador, então o que acontece aqui é o que vai acontecer no seu JavaScript.

🔒 Roda inteiramente no seu navegadorregextestpattern
Visão

Padrão

//g

pode casar em qualquer ponto da string, 2 grupos de captura.

Testar contra

Todas as ocorrências são listadas. Sem a flag `g`, o `String.replace` usa só a primeira.

0 ocorrências

Tempo

0,0 ms

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

Substituir

`$1`, `$<name>`, `$&`, `` $` ``, `$'` e `$$` expandem todos, exatamente como o `String.replace` os expande.

Como usar

  1. Escreva o padrão e defina as flags

    Os botões de flag são as seis que importam: global, ignorar maiúsculas, multilinha, dotAll, unicode e sticky. O literal no topo é o que você colaria no código.

  2. Cole um texto que você de fato tem

    As correspondências são destacadas no lugar, alternando a cor para que as adjacentes se distingam, e listadas em uma tabela com o valor de cada grupo — incluindo os grupos que não participaram.

  3. Experimente a substituição

    `$1`, `$<name>`, `$&`, `` $` ``, `$'` e `$$` se expandem exatamente como `String.replace` os expande, então a pré-visualização é a saída real.

Perguntas frequentes

Por que a página avisa que falta a flag `g`?

Porque a lista mostra todas as correspondências, mas sem `g` o seu código não vai mostrar. `String.replace` muda só a primeira, e `matchAll` lança um erro de cara. É a diferença entre o que você vê aqui e o que o seu programa faz.

É o mesmo motor do Python ou do PCRE?

Não: é o do JavaScript. Lookbehind, grupos nomeados e `\p{…}` são suportados aqui, mas grupos atômicos, quantificadores possessivos, recursão e grupos de flags inline não são, e o comportamento das classes de caracteres difere em alguns pontos. Um padrão que funciona aqui ainda pode falhar em outro lugar.

Meu padrão trava a página.

Não deveria: a correspondência roda em um worker precisamente porque um padrão com backtracking catastrófico não pode ser interrompido de nenhum outro jeito. Se demorar demais, a execução é encerrada e relatada, o que também é um sinal útil: um padrão que faz isso aqui vai fazer no seu servidor.

Por que `.` não casa com minha quebra de linha?

Porque é para isso que serve `s` (dotAll). Sem ela `.` casa com qualquer coisa exceto um terminador de linha — e `m` (multilinha) é outra coisa ainda: muda o que `^` e `$` significam, não o que `.` casa.

Pode receber de

Em seguida

Estas aceitam o que esta ferramenta produz, então o resultado pode ir direto.