Testador de Regex

Ferramenta testadora de regex online gratuita. Teste e depure expressões regulares com correspondência em tempo real, destaque de sintaxe, grupos de captura e suporte a flags. Perfeito para desenvolvedores.

Tem feedback? Reporte bugs, sugira recursos ou compartilhe suas ideias — lemos todos

Testador de Regex - Testar e Depurar Expressões Regulares

Um poderoso testador de expressões regulares online que ajuda você a testar, depurar e aprender padrões regex. Recursos incluem correspondência em tempo real com destaque de sintaxe, exibição de grupos de captura, suporte a todas as flags regex do JavaScript e informações detalhadas de correspondência. Perfeito para desenvolvedores e qualquer pessoa trabalhando com correspondência de padrões.

O que é uma expressão regular e para que serve?

Uma expressão regular (regex ou regexp) é uma sequência de caracteres que define um padrão de busca, usada para correspondência de strings, validação, extração e substituição. O conceito foi formalizado por Stephen Kleene nos anos 1950 e popularizado pelo grep de Ken Thompson em 1968. Motores modernos viabilizam validação de entradas (e-mails, telefones, CEPs), análise de logs, buscar e substituir em editores, roteamento de URLs em frameworks web e análise léxica em compiladores. Toda linguagem importante traz um motor: RegExp do JavaScript, re do Python, Pattern do Java, Regex do .NET e PCRE no PHP. Embora a sintaxe varie entre sabores (POSIX BRE, ERE, PCRE, RE2, ECMAScript), os blocos fundamentais — classes de caracteres, quantificadores, âncoras, grupos e alternância — são universais.

Qual a diferença entre quantificadores gulosos, preguiçosos e possessivos?

Por padrão, quantificadores como *, +, ? e {n,m} são gulosos: casam o máximo possível enquanto o padrão global ainda tem sucesso. O padrão <.+> em <b>negrito</b> casa a string toda, não só <b>, porque + consome tudo até o último >. Quantificadores preguiçosos (não gulosos) adicionam ? — <.+?> casa apenas <b>, pegando a menor substring que funcione. Possessivos adicionam + (++, *+, ?+) e nunca retrocedem após casar, melhorando o desempenho e evitando retrocesso catastrófico, mas podem falhar onde o guloso teria sucesso. PCRE, Java e Ruby suportam possessivos; JavaScript e Python não (use grupos atômicos (?>...) quando disponíveis).

O que são âncoras, lookahead e lookbehind?

Âncoras casam posições, não caracteres. ^ marca o início (ou de linha em modo multiline), $ o fim, \b um limite de palavra, e \A / \Z o início / fim absoluto. Lookahead (?=...) e negativo (?!...) afirmam o que vem depois sem consumir: q(?=u) casa q apenas se for seguido por u. Lookbehind (?<=...) e (?<!...) afirmam o que vem antes: (?<=\$)\d+ casa um número precedido pelo cifrão. JavaScript ganhou lookbehind no ES2018; navegadores antigos e RE2 (usado por Go e Cloudflare) não suportam. Lookarounds são de largura zero: afetam a correspondência mas não contribuem com caracteres ao resultado.

Como diferem grupos de captura, não captura e nomeados?

Parênteses (abc) criam um grupo de captura que agrupa para quantificadores e salva a substring para retrorreferências (\1) ou extração. Grupos sem captura (?:abc) agrupam sem salvar, são mais rápidos e não poluem o array de resultados — use-os sempre que só precisar agrupar. Grupos nomeados (?<nome>abc) (PCRE/Python/.NET/ES2018+) salvam sob um nome legível acessível via match.groups.nome, tornando padrões autodocumentados. Um regex como (?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2}) decompõe uma data ISO em campos rotulados. Retrorreferências \k<nome> ou \1 permitem casar o mesmo texto de novo — útil para achar palavras duplicadas como \b(\w+)\s+\1\b.

Testador de Regex — Ferramenta testadora de regex online gratuita. Teste e depure expressões regulares com correspondência em tempo real, de — **Testador de Regex**

O que são as flags comuns (g, i, m, s, u, y) e o que fazem?

Flags modificam o comportamento global do regex. g (global) retorna todas as correspondências, necessário para replaceAll em JavaScript. i (insensível a maiúsculas) faz [A-Z] casar a-z. m (multiline) muda ^ e $ para limites de linha em vez de string. s (dotall, ES2018+) permite . casar quebras de linha. u (unicode) ativa o modo Unicode completo com pares substitutos e escapes \p{Script=Latin}. y (sticky) ancora a correspondência em lastIndex, útil para tokenizadores. Python usa as constantes re.IGNORECASE, re.MULTILINE, re.DOTALL em vez de letras. Combine flags: /padrao/gim ou (?gim) inline.

Por que alguns regex travam o navegador? (retrocesso catastrófico)

Retrocesso catastrófico ocorre quando um regex tenta exponencialmente muitas formas de casar antes de desistir. O exemplo clássico é (a+)+b contra aaaaaaaaaaaaaaaaaa (sem b): o motor testa cada partição dos a's entre os + interno e externo, gerando 2^n tentativas. Ataques ReDoS (Negação de Serviço por Regex) exploram isso — uma única entrada maliciosa pode congelar um servidor por minutos. O guia ReDoS da OWASP recomenda: evitar quantificadores aninhados ((a+)+, (a*)*), evitar alternâncias sobrepostas ((a|a)+), preferir grupos atômicos (?>a+)+ ou quantificadores possessivos a++, e usar motores de tempo linear como RE2 (Go, Cloudflare) ou o crate regex do Rust para entradas não confiáveis. Teste padrões com o debugger do regex101 ou o linter regexploit.

Quais as diferenças entre POSIX BRE, ERE, PCRE e RE2?

POSIX BRE (Básico, usado por sed e grep) exige barras invertidas antes de metacaracteres: $grupo$, \{2,3\}, \+ é literal. POSIX ERE (Estendido, usado por egrep, awk) trata esses caracteres como especiais por padrão — mais próximo da sintaxe moderna. PCRE (Compatível com Perl, usado por PHP, NGINX e muitas ferramentas) é o padrão moderno de fato: suporta lookaround, grupos nomeados, retrorreferências, recursão e condicionais. RE2 (Google, usado por Go, Cloudflare, Sourcegraph) omite deliberadamente retrorreferências e lookaround para garantir tempo linear, eliminando ReDoS. O regex ECMAScript (JavaScript) é próximo ao PCRE mas carece de algumas funções (recursão, condicionais) e adiciona a flag y. Sempre consulte a documentação do motor alvo — um padrão PCRE funcional pode falhar em RE2 ou grep.

Como escapar caracteres especiais e tratar Unicode corretamente?

Doze metacaracteres precisam de escape com barra invertida: . ^ $ * + ? ( ) [ ] { } | \. Para casar um ponto literal, use \.. Dentro de classes [...], apenas ] \ ^ - precisam de escape, e ^ apenas na posição 1. Para padrões dinâmicos com entrada de usuário, use uma função de escape de biblioteca (proposta RegExp.escape, re.escape em Python, preg_quote em PHP) — nunca concatene entrada bruta. Para Unicode, ative a flag u e use escapes de propriedade: \p{L} (qualquer letra), \p{N} (número), \p{Script=Han} (caracteres chineses), \p{Emoji}. O obsoleto \w só casa ASCII por padrão — para nomes internacionais use [\p{L}\p{N}_]. Pares substitutos (emojis, CJK raros) só funcionam corretamente com a flag u em JavaScript.