Testador de regex

Como usar o testador de regex

1. Digite o seu padrão sem as barras ao redor, por exemplo \d{3}-\d{4}.
2. Ative as flags de que precisa (g, i, m, s, u, y).
3. Cole o texto de teste. As correspondências são destacadas em tempo real e cada grupo de captura é listado.
4. Se quiser, digite uma string de substituição, usando $1 ou $<nome> para os grupos, para ver uma prévia do resultado.

O testador usa o mecanismo de regex JavaScript do seu próprio navegador. Seus padrões e dados de teste ficam no seu dispositivo e não são enviados nem armazenados.

Sintaxe de regex em JavaScript em resumo

As variantes (flavors) de expressões regulares variam entre as linguagens. Esta ferramenta usa a variante JavaScript (ECMAScript), então os resultados correspondem ao que RegExp, String.prototype.match e replace fazem em navegadores e no Node.js. A maior parte da sintaxe vale também para Python, PCRE e Java, mas detalhes como a sintaxe de grupos nomeados e o suporte a lookbehind variam.

Flags

Blocos de construção

• Classes de caracteres: [abc], intervalos [a-z], negação [^0-9], atalhos \d (dígito), \w (caractere de palavra), \s (espaço em branco) e suas negações \D, \W, \S. Sem a flag u, \w e \d cobrem apenas ASCII.
• Quantificadores: * (0 ou mais), + (1 ou mais), ? (0 ou 1), {n}, {n,}, {n,m}. Acrescente ? para torná-los preguiçosos (lazy): .*?.
• Grupos: (...) captura, (?:...) agrupa sem capturar, (?<year>\d{4}) cria um grupo nomeado, e \1 ou \k<year> faz referência a ele.
• Âncoras: ^, $ e o limite de palavra \b.
• Lookarounds: (?=...) lookahead positivo, (?!...) lookahead negativo, (?<=...) lookbehind positivo, (?<!...) lookbehind negativo. Eles testam o contexto sem consumir caracteres.

// Valores de preço precedidos por um cifrão, sem o cifrão
/(?<=\$)\d+(?:\.\d{2})?/g     "Total: $42.50"  →  "42.50"

// Reformatar datas com grupos nomeados
"2024-03-15".replace(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/, "$<d>.$<m>.$<y>")
// "15.03.2024"

Padrões comuns

Para endereços IP especificamente, o conversor de endereço IP analisa e converte tanto IPv4 quanto IPv6.

Armadilhas

Backtracking catastrófico

Quantificadores aninhados ou sobrepostos podem fazer um mecanismo com backtracking, como o do JavaScript, tentar um número exponencial de caminhos quando uma correspondência falha. Algumas dezenas de caracteres podem travar uma aba do navegador ou, em um servidor, permitir um ataque de negação de serviço (ReDoS):

/^(a+)+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!")   // pode travar

/^a+$/.test("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!")       // instantâneo

Evite padrões como (a+)+, (a|a)* ou (.*)*, mantenha as alternativas mutuamente exclusivas e seja específico: [^"]* é mais seguro que .* dentro de aspas.

Outras pegadinhas

• Uma regex com a flag g guarda o lastIndex, então chamar test() repetidamente no mesmo objeto alterna entre true e false.
• Ao montar um padrão a partir de uma string, as barras invertidas devem ser dobradas: new RegExp("\\d+").
• Esquecer ^ e $ significa que um validador aceita qualquer entrada que apenas contenha uma correspondência.

Perguntas frequentes

Por que a minha regex funciona aqui, mas não em Python ou PHP?

As variantes diferem. O Python escreve grupos nomeados como (?P<name>...) e só aceita lookbehind de largura fixa; o PCRE do PHP envolve os padrões em delimitadores. As regras de escape para literais de string também variam entre as linguagens.

Qual é a diferença entre quantificadores gananciosos e preguiçosos?

Os quantificadores gananciosos (.*) correspondem ao máximo possível e depois recuam; os preguiçosos (.*?) correspondem ao mínimo possível. Em <b>x</b>, <.*> corresponde à string inteira, enquanto <.*?> corresponde apenas a <b>.

O JavaScript aceita lookbehind?

Sim, desde o ES2018 e, ao contrário de muitos mecanismos, permite lookbehind de comprimento variável. Todos os principais navegadores atuais o aceitam.

Como faço a correspondência com um ponto ou colchete literal?

Use o escape com uma barra invertida: \., \[, \(. Dentro de uma classe de caracteres, a maioria dos caracteres é literal, então [.] também corresponde a um ponto.

Atualizado 2026-10-17