Testador de expressões regulares

Por que regex vale a pena aprender (e quando não usar)

Expressões regulares são a ferramenta universal de análise de texto — cada linguagem moderna tem elas, a sintaxe geralmente se transfere, e são a resposta certa para ~80% de trabalhos "encontre este padrão". Os 20% restantes:

• Analisar HTML ou XML com regex — não. Use um analisador real (DOMParser no navegador, cheerio no Node).
• Analisar JSON com regex — não. Use JSON.parse.
• Validação de email com regex — geralmente errado; use uma biblioteca ou o built-in do seu provedor de autenticação.
• Delimitadores aninhados profundos ou equilibrados — regex não consegue (formalmente) corresponder esses. Use um analisador.

Para tudo mais: extraindo URLs, dividindo texto tipo CSV, validando formatos de telefone, correspondendo linhas de log, encontrando comentários TODO — regex é a ferramenta certa.

Os cinco conceitos que valem a pena memorizar

Você pode escrever 90% de regex útil com essas cinco primitivas:

1. Classes de caractere: \d (dígito), \w (caractere de palavra), \s (espaço em branco) e suas negações em maiúsculas. Mais classes personalizadas: [a-z], [^xyz].
2. Quantificadores: * (0+), + (1+), ? (0 ou 1), {n,m} (entre n e m). Adicione ? para torná-los preguiçosos: *?, +?.
3. Âncoras: ^ (início), $ (fim), \b (limite de palavra).
4. Grupos: (…) captura, (?:…) não captura (mais barato), (?<name>…) captura com um nome.
5. Alternação: a|b — a ou b.

Combine esses e você pode corresponder a maioria das coisas. O resto da sintaxe regex (lookahead, backreferences, classes unicode, etc.) é ocasionalmente útil mas pulável para trabalho diário.

Os quirks específicos do JavaScript

JS regex (por ECMAScript) é quase PCRE mas não exatamente:

• Sem (?#comment) — JS regex não tem sintaxe de comentário. Comente seu código em vez disso.
• . NÃO corresponde quebras de linha a menos que você defina a bandeira s (dotAll). Frequente fonte de "por que isso não está correspondendo?".
• \b usa limites de palavra ASCII por padrão. Definir a bandeira u muda isso. Adicione u sempre que manipular texto não-ASCII.
• Grupos nomeados usam (?<name>…) — estilo Python. JS adotou isso em 2018; assuma navegadores/Node modernos.
• Backreferences em replace usam $1, $2, $<name> — não \1 como Perl.

Outras linguagens fazem as coisas um pouco diferente. PCRE é um quase-superset de JS regex; Python re é similar mas usa (?P<name>…) para grupos nomeados; o pacote regexp do Go é RE2 (sem backreferences, sem lookahead, mas tempo linear garantido). Não cole uma regex Python em JS sem verificar.

Rastreamento catastrófico — a única pegadilha de desempenho

Um padrão como (a+)+b correspondido contra aaaaaaaaaaaaaaaaaaaaa (sem b final) leva tempo exponencial conforme a entrada cresce. O mecanismo de regex tenta todas as maneiras possíveis de particionar os as entre os dois quantificadores, desiste, depois tenta a próxima combinação. Com 20 as e sem b, isso é milhões de tentativas.

Esta ferramenta define um teto de execução de 1 segundo precisamente porque padrões patológicos podem travar uma aba de navegador indefinidamente.

Regras de evitação:

• Não aninhe quantificadores sem pensar. (a+)+, (a*)*, (a|aa)+ são bandeiras vermelhas.
• Use grupos atômicos ou quantificadores possessivos se seu mecanismo suportar (JS não — use truques de lookahead).
• Seja específico. [^"]*" corresponde até a próxima aspas; melhor que .*" que pode fazer rastreamento.
• Teste com entrada adversarial. Um padrão que manipula seu caminho feliz pode explodir em entrada terminando em alguns caracteres não correspondidos.

Se um padrão está levando muito tempo, a resposta raramente é "adicione mais +" — geralmente é "reescreva para ser linear", ou "use um analisador real".

Como esta ferramenta ajuda

• Cole um padrão e texto; correspondências destacam ao vivo.
• As bandeiras são alternáveis; você as vê na visualização do padrão (/foo/gi).
• Grupos de captura e grupos nomeados aparecem sob cada correspondência.
• Modo de substituição visualiza o resultado de text.replace(pattern, replacement).
• Teto de execução de 1 segundo pega rastreamento catastrófico antes que sua aba congele.

Um cheatsheet de padrões que funcionam

Não à prova de bala — aquele de email aceita muitos endereços inválidos — mas bom o suficiente para filtrar e extração.

Privacidade

Toda correspondência de regex é executada no navegador via mecanismo nativo RegExp. Nós não enviamos seus padrões ou texto para lugar nenhum.

Ferramentas relacionadas

• Text Case Converter — mude o caso do texto correspondido.
• Slugify — transforme texto arbitrário em slugs seguros para URL (uma transformação regex de nível mais alto).
• JSON Formatter — quando suas correspondências acabam precisando formatação JSON.

O que é rastreamento catastrófico?

Uma patologia de desempenho de regex onde o mecanismo explora exponencialmente muitas maneiras de particionar entrada através de quantificadores aninhados. Padrões como (a+)+b contra aaaaaaaa… (sem b) ficam indefinidamente. Esta ferramenta limita a execução a 1 segundo e relata o problema.

Quantificador ganancioso versus preguiçoso?

* e + são gananciosos — eles correspondem o máximo possível. Adicione ? (*?, +?) para torná-los preguiçosos — corresponda o mínimo possível. Para <.*> em <a><b> você obtém a string inteira; <.*?> fornece apenas <a>.

Por que corresponder HTML é difícil?

HTML não é uma linguagem regular — tem aninhamento arbitrário que regex não consegue (formalmente) lidar. Você pode corresponder casos simples muito específicos, mas HTML do mundo real tem comentários, CDATA, tags malformadas e espaço em branco estranho. Use DOMParser no navegador ou cheerio no Node em vez disso.

Como faço para corresponder caracteres Unicode?

Adicione a bandeira u. Então \w cobre mais caracteres, e você pode usar \p{Letter} / \p{Script=Vietnamese} estilo escape de propriedade Unicode (Node 10+/todos os navegadores modernos).

Diferença entre (?:…) e (…)?

(…) cria um grupo de captura numerado, acessível como $1 etc. (?:…) agrupa para o quantificador sem capturar. Use não-captura quando você não precisa do valor — é ligeiramente mais rápido e mantém seus índices de captura limpos.

O que são lookahead e lookbehind?

Afirmações zero-width: (?=…) corresponde se … segue mas não o consome; (?!…) corresponde se … NÃO segue; (?<=…) e (?<!…) são o mesmo para o que precede. Útil para "corresponder X mas apenas quando não seguido por Y" sem consumir Y.

JS regex vs PCRE — qual é a diferença?

JS é principalmente um subconjunto de PCRE com algumas diferenças. Sem comentários inline (?#…), sem quantificadores possessivos, grupos nomeados usam (?<name>…) não (?P<name>…) (que é Python). Não cole regex aleatório da internet em JS sem verificar.

Por que meu padrão não corresponde quebras de linha?

. não corresponde \n por padrão. Adicione a bandeira s (dotAll) para fazer . corresponder qualquer caractere incluindo quebra de linha. Alternativa: use [\s\S] que sempre corresponde a qualquer coisa.