Testador de Regex com Explicação — Ferramenta Online Grátis

Teste expressões regulares em tempo real com destaque de correspondências, captura de grupos e explicações em português.

/ /

Referência Rápida — clique para inserir

O que é uma Expressão Regular?

Uma expressão regular (regex ou regexp) é uma sequência de caracteres que define um padrão de busca. São usadas para busca em strings, validação, extração de texto e substituição. Regex é suportado em praticamente todas as linguagens de programação e é uma ferramenta essencial para qualquer desenvolvedor que trabalha com processamento de texto.

Referência Rápida de Sintaxe Regex

  • . — Corresponde a qualquer caractere exceto nova linha
  • ^ / $ — Início / fim da string (ou linha no modo multilinha)
  • * / + / ? — 0 ou mais / 1 ou mais / 0 ou 1
  • {n,m} — Entre n e m repetições
  • [abc] — Classe de caracteres — corresponde a a, b ou c
  • [^abc] — Classe de caracteres negada
  • (abc) — Grupo de captura
  • (?:abc) — Grupo sem captura
  • \d / \w / \s — Dígito / caractere de palavra / espaço em branco
  • a|b — Alternância — corresponde a a ou b

Padrões Regex Comuns

  • Email: [\w.+-]+@[\w-]+\.[a-zA-Z]{2,}
  • URL: https?://[\w\-._~:/?#[\]@!$&'()*+,;=%]+
  • IPv4: (\d{1,3}\.){3}\d{1,3}
  • Telefone (BR): \(?\d{2}\)?[\s.-]?\d{4,5}[\s.-]?\d{4}
  • Cor hex: #([a-fA-F0-9]{6}|[a-fA-F0-9]{3})
  • Data (AAAA-MM-DD): \d{4}-\d{2}-\d{2}

Dominando Expressões Regulares: Padrões que Todo Desenvolvedor Deve Conhecer

As expressões regulares são uma das ferramentas mais poderosas no kit de um desenvolvedor, mas também uma das mais mal compreendidas. A chave para escrever regex eficaz é entender os blocos de construção e combiná-los metodicamente, em vez de tentar escrever padrões complexos do zero.

Padrões Regex Essenciais para Tarefas Comuns

  • Validação de Email: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ — Cobre 99% dos formatos de email válidos. Para produção, considere usar o validador de email integrado da sua linguagem além do regex.
  • Correspondência de URL: https?://[^\s/$.?#].[^\s]* — Corresponde a URLs HTTP e HTTPS. Simples mas eficaz para extrair links de texto.
  • Endereço IPv4: \b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b — Corresponde ao formato de endereço IP. Não valida faixas.
  • Formato de Data (YYYY-MM-DD): \d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]) — Corresponde ao formato de data ISO 8601 com validação básica de mês/dia.
  • Força de Senha: ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$ — Requer pelo menos 8 caracteres com maiúscula, minúscula, dígito e caractere especial.

Performance de Regex: Evitando Backtracking Catastrófico

O backtracking catastrófico ocorre quando um motor de regex fica preso tentando combinações exponencialmente numerosas em certas entradas. Isso pode congelar sua aplicação ou causar ataques ReDoS (Negação de Serviço por Expressão Regular).

  • Padrão perigoso: (a+)+$ — Na entrada "aaaaaaaaaaaaaaaaab", leva tempo exponencial porque o motor tenta cada forma possível de dividir os a's entre os grupos interno e externo.
  • Alternativa segura: a+$ — Achate quantificadores aninhados quando possível.
  • Regra geral: Evite aninhar quantificadores (como (x+)+, (x*)*, ou (x+)*) a menos que tenha certeza de que o padrão interno não pode corresponder aos mesmos caracteres da repetição externa.

Em aplicações de produção, sempre defina um timeout para operações regex e considere usar bibliotecas regex que suportem correspondência em tempo linear (como RE2 para Go ou rust-regex para Rust).

Variantes de Regex: Diferenças Chave entre Linguagens

Nem todos os motores de regex são iguais. Aqui estão as diferenças importantes:

  • JavaScript: Sem suporte a lookbehind até ES2018. Usa sintaxe /pattern/flags. A flag g é stateful com lastIndex.
  • Python: Usa o módulo re. Suporta grupos nomeados com sintaxe (?P<name>...).
  • Go: Usa motor RE2 — sem backtracking, garante tempo linear, mas não suporta lookahead/lookbehind.
  • Java: Suporte completo similar ao PCRE incluindo quantificadores possessivos (a++) e grupos atômicos.

Perguntas Frequentes sobre Expressões Regulares

Qual a diferença entre .* e .+ em regex?

O asterisco (*) significa "zero ou mais" do elemento anterior, enquanto o mais (+) significa "um ou mais". O padrão .* corresponde a qualquer string incluindo strings vazias, enquanto .+ requer pelo menos um caractere. Ambos são gananciosos por padrão — correspondem ao máximo possível. Adicione ? para torná-los preguiçosos (corresponder o mínimo possível): .*? e .+?.

O que fazem as flags g, i, m e s em regex?

A flag g (global) encontra todas as correspondências em vez de parar na primeira. A flag i torna a correspondência insensível a maiúsculas/minúsculas. A flag m (multilinha) faz ^ e $ corresponderem ao início e fim de cada linha ao invés da string inteira. A flag s (dotAll) faz o ponto corresponder a caracteres de nova linha. Combine flags conforme necessário: /padrão/gim.

Como corresponder um ponto literal, parênteses ou outros caracteres especiais?

Escape caracteres especiais de regex com uma barra invertida. Um ponto literal é \. (sem a barra invertida, o ponto corresponde a qualquer caractere). Um parêntese literal é \( e \). Outros caracteres que precisam de escape: \ ^ $ | ? * + { } [ ]. Por exemplo, para corresponder a URL example.com literalmente, escreva /example\.com/ — caso contrário, o ponto corresponderia a qualquer caractere.

Qual a diferença entre um quantificador ganancioso e um preguiçoso?

Quantificadores gananciosos (*, +, {n,m}) tentam corresponder ao máximo possível enquanto ainda permitem que o padrão geral funcione. Quantificadores preguiçosos (não-gananciosos) (*?, +?, {n,m}?) correspondem ao mínimo possível. Por exemplo, dado <b>negrito</b>, o ganancioso /<.*>/ corresponde à string inteira, enquanto o preguiçoso /<.*?>/ corresponde apenas a <b>.

Ferramentas Relacionadas para Desenvolvedores