Copa do Mundo 2026 — acompanhe os horários dos jogos no seu fuso Ver jogos →
Testador de Regex

Testador de Regex

Teste e valide expressões regulares em tempo real com destaque de correspondências, grupos de captura e suporte a flags. Gratuito, sem cadastro.

Atualizado em maio de 2026

/ /g
Test String
Code Generator 
const regex = /your-pattern/g;
const str = `Contact support at help@blueprint-precision.com or send queries to admin@system.internal.
Please rea`;
let m;

while ((m = regex.exec(str)) !== null) {
  if (m.index === regex.lastIndex) {
    regex.lastIndex++;
  }
  // The result can be accessed through the `m` variable.
  m.forEach((match, groupIndex) => {
    console.log(`Found match, group ${groupIndex}: ${match}`);
  });
}
Regex Explanation

Enter a pattern above to see it explained token by token.

Pattern Library

Testador de Regex Online — Depurador de Expressões Regulares em Tempo Real

Teste e depure qualquer expressão regular diretamente no navegador, sem instalar nada. Nosso Testador de Regex destaca as correspondências em tempo real no texto de teste, exibe grupos de captura com suas posições exatas, oferece botões para ativar as flags g, i, m e s, explica cada token do padrão e gera código pronto para JavaScript, Python ou PHP — tudo isso sem precisar criar conta.

Seja para validar e-mails, extrair datas de logs ou construir padrões complexos para um parser, você vê exatamente o que a expressão captura enquanto digita.

Como Usar o Testador de Regex

  1. Digite o padrão — Insira sua expressão regular no campo de padrão. As barras / são exibidas automaticamente ao redor; basta digitar o padrão em si. O painel de explicação à direita detalha cada token imediatamente, mostrando o que cada parte faz.
  2. Ative as flags — Clique em g (global), i (sem distinção de maiúsculas), m (multilinha) ou s (dotAll) para alterar o comportamento da correspondência em tempo real. O padrão exibido ao lado do campo é atualizado com as flags ativas e o contador de correspondências é atualizado imediatamente.
  3. Cole o texto de teste — Insira o texto que deseja verificar na área de Texto de Teste. As partes correspondentes são destacadas em amarelo enquanto você digita, e um indicador acima do campo mostra o total de correspondências encontradas. Se nada corresponder, aparece a mensagem "Sem correspondências" — indicação imediata de que o padrão precisa de ajuste.
  4. Inspecione os resultados — O painel de Resultados ao Vivo lista cada correspondência com número sequencial, texto capturado e posições de início e fim em caracteres. Os grupos de captura são exibidos separadamente para cada correspondência, incluindo grupos nomeados com a sintaxe (?<nome>...).
  5. Copie o código gerado — No painel Gerador de Código, alterne entre JavaScript, Python e PHP e clique em "Copiar Snippet" para obter código pronto para produção com seu padrão, texto de teste e flags atuais — pronto para colar no seu projeto.
  6. Use um padrão da biblioteca — Clique em qualquer item da Biblioteca de Padrões (E-mail, URL, IPv4, Telefone, Data, Cor Hex) para carregar o padrão e um texto de exemplo na ferramenta instantaneamente, depois adapte-o às suas necessidades.

Expressões Regulares — O Que São e Por Que Importam

Uma expressão regular é uma notação compacta para descrever padrões em texto. Inventadas na década de 1950 pelo matemático Stephen Kleene, as expressões regulares estão integradas a todas as principais linguagens de programação e são indispensáveis para validação de dados, análise de logs, operações de busca e substituição e extração de informações estruturadas.

A grande vantagem das expressões regulares é que elas descrevem estrutura, não valores específicos — \d{4}-\d{2}-\d{2} corresponde a qualquer data no formato ISO sem precisar enumerar cada data possível. Essa expressividade é o que torna as regex tão poderosas para ferramentas de desenvolvimento e pipelines de processamento de texto.

Casos de Uso Comuns

  • Validação de e-mail: Use ^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$ para validar o formato do e-mail no cliente antes de enviar ao servidor.
  • Validação de CPF: O padrão ^\d{3}\.?\d{3}\.?\d{3}-?\d{2}$ verifica o formato básico de um CPF brasileiro.
  • Análise de logs: Extraia timestamps, endereços IP ou códigos de erro de arquivos de log usando âncoras e classes de caracteres.
  • Sanitização de formulários: Remova caracteres não permitidos com uma classe negada como [^a-zA-Z0-9\s] antes de armazenar a entrada do usuário.
  • Geração de slugs de URL: Converta um título em um slug seguro para URLs substituindo espaços e caracteres especiais: [^\w\s-] → remover, [\s_-]+ → substituir por -.
  • Validação de senha: Verifique se uma senha contém pelo menos uma letra maiúscula, um dígito e um caractere especial usando lookaheads: (?=.*[A-Z])(?=.*\d)(?=.*[\W_]).

Exemplos de Expressões Regulares

Esses padrões cobrem os casos de uso reais mais comuns. Cole o texto de teste na ferramenta e digite o padrão para ver os resultados ao vivo.

Padrão Texto de Teste O Que Corresponde
\d+ Pedido 1234 feito em 2024-01-15 1234, 2024, 01, 15
\b[A-Z][a-z]+\b Alice e Bob foram a Paris Alice, Bob, Paris
[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,} Contato: ola@exemplo.com.br hoje ola@exemplo.com.br
https?:\/\/\S+ Visite https://exemplo.com ou http://teste.org Ambas as URLs completas
^(\d{4})-(\d{2})-(\d{2})$ 2024-01-15 Correspondência completa + 3 grupos: 2024, 01, 15
#[0-9a-fA-F]{3,6} Cor primária #1a73e8, borda #ccc #1a73e8, #ccc
<.+> <b>negrito</b> <b>negrito</b> (string inteira — guloso)
<.+?> <b>negrito</b> <b> e depois </b> (cada tag — não-guloso)

Caso especial — sem correspondências: Se o padrão não encontrar nada, o indicador acima do campo mostra "Sem correspondências" e nenhum destaque aparece. Esse é o sinal imediato de que o padrão precisa ser revisado.

Caso especial — guloso vs. preguiçoso: No texto <b>negrito</b><i>itálico</i>, o padrão guloso <.+> corresponde ao trecho inteiro do primeiro < ao último >. O padrão preguiçoso <.+?> corresponde a cada tag individualmente: <b>, </b>, <i>, </i>. Use quantificadores preguiçosos (*?, +?) sempre que precisar da correspondência mais curta entre dois delimitadores.

Caso especial — backtracking catastrófico: O padrão (a+)+ em uma string como aaaaaac força o motor a tentar um número exponencialmente crescente de combinações antes de confirmar que não há correspondência. Em strings mais longas isso pode travar a aba do navegador. Se a ferramenta parecer lenta após inserir um padrão, simplifique os quantificadores aninhados e teste com strings que não correspondem para medir o pior caso.

Erros Comuns com Expressões Regulares

Conhecer as armadilhas mais frequentes poupa horas de depuração:

  • Esquecer de escapar caracteres especiais. O ponto . corresponde a qualquer caractere, não a um ponto literal. Para corresponder a um ponto real — por exemplo, em um domínio — use \.. O mesmo vale para (, ), [, ], {, }, *, +, ?, ^, $ e |.
  • Quantificadores gulosos capturando demais. .* consome tudo que pode antes de ceder o controle ao restante do padrão. Use .*? (preguiçoso) para corresponder ao menor trecho possível.
  • Âncoras e modo multilinha. ^ e $ correspondem ao início e ao fim de toda a string por padrão. Com a flag m (multilinha) ativa, elas correspondem ao início e ao fim de cada linha. Esquecer de ativar m ao trabalhar com texto de múltiplas linhas é uma causa frequente de bugs do tipo "apenas a primeira linha corresponde".
  • Esquecer a flag g. Sem a flag global, apenas a primeira correspondência é encontrada. Ative g para coletar todas — o indicador na ferramenta mostra a quantidade imediatamente.
  • Sensibilidade a maiúsculas. Por padrão, [A-Z] corresponde apenas a letras maiúsculas. Adicione a flag i para que o padrão ignore diferenças entre maiúsculas e minúsculas.
  • Retrocesso catastrófico. Padrões como (a+)+ em uma string longa sem correspondência forçam o motor a tentar um número exponencial de combinações, podendo travar a aplicação. Simplifique quantificadores aninhados e sempre teste com strings que não correspondam.

Perguntas Frequentes

O que é um Testador de Regex e como ele ajuda desenvolvedores?

Um Testador de Regex é uma ferramenta que permite escrever uma expressão regular e ver instantaneamente quais partes do texto de teste ela corresponde — com destaque visual, informações de posição e detalhes dos grupos capturados. Em vez de adicionar console.log ao código e executá-lo, você itera sobre o padrão diretamente e só o copia para o projeto quando está correto. Isso economiza muito tempo de depuração, especialmente em padrões complexos.

Quais flags de regex esta ferramenta suporta?

A ferramenta suporta as quatro flags mais utilizadas: g (global — encontrar todas as correspondências em vez de parar na primeira), i (sem distinção de maiúsculas), m (multilinha — faz ^ e $ corresponderem ao início e fim de cada linha) e s (dotAll — faz . corresponder também a quebras de linha). As flags podem ser combinadas livremente clicando em múltiplos botões.

Por que minha regex está capturando mais texto do que eu esperava?

Na maioria dos casos, quantificadores gulosos são a causa. .*, .+ e similares consomem o máximo possível de caracteres antes de permitir que o restante do padrão corresponda. Por exemplo, ".*" no texto "primeiro" e "segundo" corresponde ao trecho inteiro do primeiro ao último ". Mude para ".*?" (preguiçoso) para obter duas correspondências separadas. Teste as duas versões na ferramenta para ver a diferença imediatamente.

O que a flag g faz e quando preciso usá-la?

A flag g (global) instrui o motor a continuar buscando após cada correspondência em vez de parar na primeira. Sem g, apenas a primeira correspondência é encontrada e listada nos resultados. Com g, todas as correspondências são coletadas. Use g sempre que quiser contar ocorrências, substituir todas as instâncias ou extrair múltiplos valores de uma string.

Qual é a diferença entre correspondência gulosa e preguiçosa?

Quantificadores gulosos (*, +, ?) correspondem ao máximo de texto possível. Quantificadores preguiçosos (*?, +?, ??) correspondem ao mínimo possível. No texto <b>negrito</b><i>itálico</i>, o padrão guloso <.+> corresponde ao trecho inteiro de <b> a </i>. O preguiçoso <.+?> corresponde a cada tag individualmente. Use quantificadores preguiçosos quando precisar da menor string possível entre dois delimitadores.

Como funcionam os grupos de captura?

Grupos de captura são partes do padrão envolvidas por parênteses ( ). Quando uma correspondência é encontrada, o motor registra separadamente a substring que cada grupo capturou. O Grupo 1 captura o conteúdo do primeiro (...), o Grupo 2 do segundo, e assim por diante. Grupos nomeados como (?<ano>\d{4}) no JavaScript (ou (?P<ano>\d{4}) no Python) permitem acessar o valor pelo nome em vez do índice. Esta ferramenta exibe grupos numerados e nomeados no painel de Resultados ao Vivo.

Por que meu regex funciona em Python mas não em JavaScript?

Diferentes linguagens usam engines de regex com pequenas diferenças de sintaxe. Python usa (?P<nome>...) para grupos nomeados, enquanto JavaScript usa (?<nome>...); Python suporta lookbehind de comprimento variável, enquanto JavaScript tem suporte mais limitado (ES2018+). Sempre teste o padrão na mesma linguagem que usará em produção. O Gerador de Código da ferramenta mostra o padrão já formatado para cada linguagem.

Recursos

Ferramentas Relacionadas