Testar e Depurar Expressões Regulares
Teste um padrão regex e veja correspondências, grupos e flags ao vivo enquanto digita.
Padrão e amostra ficam no seu aparelho
Nada para apagar depois
Seguro para amostras reais de produção
Funciona em todo navegador moderno
Como funciona
- 1
Escreva seu padrão
Coloque no campo e ligue as flags que você pretende usar em produção.
- 2
Cole texto representativo
Inclua os casos chatos e as strings que não deveriam casar de jeito nenhum.
- 3
Leia correspondências e grupos
Confira o que foi achado e o que foi pulado antes de levar o padrão a qualquer lugar.
Por que usar esta ferramenta
Cada correspondência destacada ao vivo
Veja o que o padrão realmente pega enquanto você o escreve, em vez de adivinhar pela sintaxe.
Grupos de captura abertos
Grupos numerados e nomeados listados por correspondência, que é onde a maioria dos padrões erra.
Flags que você consegue ver
Global, sem distinguir caixa, multilinha e dotall mostradas explicitamente e não enterradas num delimitador.
Teste também o que não deve casar
Cole as strings que precisam ser rejeitadas ao lado das que precisam casar — essa é a metade que se pula.
Nada é enviado
O padrão e o texto de amostra ficam no seu navegador, e linhas de log reais nunca chegam a um servidor.
Grátis e sem conta
Sem cadastro, sem marca d’água e sem limite de quanto você testa.
Um padrão que casa com os seus exemplos não é um padrão que funciona
Quase todo mundo testa do mesmo jeito: escreve a expressão, cola três strings que ela deveria pegar, vê destacadas, publica. Isso confirma que o padrão não está completamente quebrado e não diz nada sobre a falha que de fato vai morder. A pergunta interessante não é o que ele casa, mas o que ele casa além disso — a entrada que você nunca pensou e que passa, e a entrada válida que ele rejeita em silêncio. Um padrão de telefone que funciona em quatro exemplos vai encontrar um prefixo internacional, um ramal ou um espaço num lugar inesperado. Então a disciplina que vale adotar é colar de propósito as strings que precisam ser rejeitadas, ao lado das que precisam ser pegas, e conferir as duas listas cada vez que o padrão muda.
Alguns padrões conseguem travar o processo que os executa
Esta é a falha que transforma uma expressão regular numa queda de serviço, e vale conhecer porque é invisível até acontecer. A maioria dos motores casa por retrocesso: quando um ramo falha, eles voltam e tentam outro. Com quantificadores aninhados — um grupo repetido que se repete, do formato `(a+)+` — o número de arranjos a tentar cresce exponencialmente com o tamanho da entrada. Numa string que casa, termina na hora; numa que *quase* casa e falha no fim, pode rodar por mais tempo do que o universo existe. Isso é um vetor de negação de serviço quando o padrão é aplicado a entrada de usuário, e já derrubou serviços grandes: tanto Cloudflare quanto Stack Overflow publicaram análises pós-incidente atribuindo uma queda global exatamente a isso. Se o seu padrão tem um quantificador dentro de um grupo quantificado, teste com uma string longa que não casa antes de ele chegar perto de produção.
Não existe uma única linguagem de expressões regulares
A sintaxe parece portátil e não é. JavaScript, PCRE como usada por PHP e Perl, Python, Java, .NET e as ferramentas POSIX implementam cada uma um dialeto diferente, e padrões viajam entre eles com mudanças silenciosas de significado. Lookbehind é uma armadilha comum: está no PCRE há décadas e só chegou ao JavaScript recentemente, então um padrão que funciona no seu editor pode falhar num navegador. Go e vários outros sistemas usam RE2, que é um projeto totalmente diferente — garante tempo linear, então o retrocesso catastrófico acima é impossível, mas consegue isso descartando retrorreferências e lookaround por completo. A sintaxe de grupos nomeados, os escapes de propriedade Unicode e até o que `\d` inclui variam. Teste no dialeto em que vai implantar, porque senão o resultado é passar aqui e falhar lá.
Guloso por padrão, e o ponto é mais estreito do que você pensa
Dois padrões de comportamento explicam boa parte das expressões que agem de forma estranha. Quantificadores são gulosos: `.*` pega o quanto pode e só devolve o indispensável, então `<.*>` aplicado a `<a><b>` casa a string inteira em vez da primeira tag. Acrescentar um sinal de interrogação o torna preguiçoso — `<.*?>` — e casa cada tag separadamente, que é quase sempre o que se pretendia. O segundo é que o ponto não casa com uma quebra de linha. Isso é invisível em exemplos de uma linha e vira mistério no instante em que o padrão encontra um documento de várias e para na primeira quebra; a flag dotall resolve. Um par relacionado vale manter separado: a flag multilinha muda o que `^` e `$` significam, ancorando-os a cada linha em vez de à string toda, e não faz nada ao ponto.
Para que não usar uma expressão regular
O conselho de não parsear HTML com regex costuma vir como piada, e a razão de fundo é precisa: HTML aninha a profundidade arbitrária, casar uma tag de abertura com o fechamento exige contar, e uma expressão regular não tem memória para contar. Não é questão de escrever um padrão melhor — a classe de linguagem é a errada. Endereços de e-mail falham de outro jeito. A gramática da RFC 5322 permite strings entre aspas, comentários e caracteres que ninguém espera, então um padrão de fato conforme chega a milhares de caracteres e ainda assim não consegue dizer a única coisa que importa, que é se o endereço recebe mensagens. A regra prática para os dois: use um parser de verdade para marcação estruturada e, para um endereço, confira que existe um `@` com algo de cada lado e então mande uma mensagem de confirmação.
Por que testar localmente importa neste tipo de texto
O padrão em si raramente é sensível. O que você cola para testá-lo normalmente é, porque uma expressão regular só vale ser testada contra entrada realista — ou seja, linhas de log reais com endereços reais dentro, uma exportação de registros de clientes que você tenta limpar, uma amostra de dados de produção que você copiou justamente porque os exemplos sintéticos não pegavam o problema. É esse material que torna o teste significativo e é o material que você não escolheria entregar a um terceiro. Esta ferramenta roda a correspondência na página e não transmite nem o padrão nem a amostra, o que você confere na aba Rede das ferramentas de desenvolvedor.
Erros comuns que vale evitar
- Testar só strings que deveriam casar. A falha que morde é a entrada que você nunca pensou passando — cole também as que precisam ser rejeitadas cada vez que o padrão muda.
- Aninhar um quantificador dentro de um grupo quantificado. Formatos como `(a+)+` retrocedem exponencialmente numa entrada que quase casa, um vetor de negação de serviço com quedas globais documentadas.
- Supor que o padrão é portátil. Lookbehind, grupos nomeados e escapes Unicode diferem entre JavaScript, PCRE, Python e RE2 — teste no dialeto de implantação.
- Esquecer que `.` não casa com quebra de linha. Um padrão que funciona numa linha para na primeira quebra de um documento; o que você quer é dotall, não multilinha.
- Parsear HTML ou validar e-mail com regex. Aninhamento exige um contador que a regex não tem, e um padrão de e-mail conforme ainda não diz se o endereço recebe mensagens.
Comparação
| Item | Esta ferramenta | Testadores online | O painel de busca de um editor |
|---|---|---|---|
| Conteúdo enviado a um servidor | Nunca | Geralmente sim | Não |
| Grupos de captura abertos | Sim | Geralmente | Raramente |
| Flags mostradas explicitamente | Sim | Geralmente | Em parte |
| Funciona sem abrir um projeto | Sim | Sim | Não |
| Conta ou cadastro | Não precisa | Às vezes exigido | Não precisa |
| Preço | Grátis | Grátis / planos pagos | Grátis / pago |
Recursos
Destaque ao vivo
Correspondências marcadas no texto de amostra conforme o padrão muda, com detalhe ao passar o mouse.
Grupos nomeados e numerados
Cada captura listada por correspondência, para ver qual grupo guarda o quê.
Todas as flags comuns
Global, ignorar caixa, multilinha, dotall, unicode e sticky, cada uma alternável separadamente.
Contagem e posições
Quantos acertos e onde começam, o que importa quando você substitui e não só quando busca.
Erros de sintaxe explicados
Um colchete sem fechar ou um escape ruim diz o que está errado em vez de não casar nada em silêncio.
Aguenta entradas longas
Arquivos de log inteiros podem ser colados como sujeito de teste sem upload.
Nada para instalar
Sem editor, sem runtime, sem dependências — funciona na página web.
Compatível com árabe e RTL
Interface completa em oito idiomas, incluindo árabe da direita para a esquerda.
Seguro por padrão
Servido por HTTPS, sem rastreio de conteúdo e sem envio a terceiros.
Quem usa
Desenvolvedores
Acertar um padrão contra dados de amostra reais antes de colocá-lo no código.
Analistas de dados
Montar um padrão de extração para uma coluna suja e ver exatamente o que escapa.
Administradores de sistemas
Conferir uma expressão de filtro de log contra linhas de log de verdade e não inventadas.
Quem está aprendendo expressões regulares
Ver o que um padrão faz enquanto você o muda, que é mais rápido que ler sobre isso.
Perguntas Frequentes
Não. Tudo roda localmente no seu navegador — seu texto nunca é enviado, armazenado ou compartilhado.
Sim — totalmente grátis, sem conta e sem limites.