T
regex debugging web-development javascript programming

Como resolver 'invalid regular expression' e erros comuns de Regex

Um guia completo para corrigir erros de Regex como 'unterminated character class', 'lookahead not supported' e 'catastrophic backtracking'. Aprenda a otimizar suas expressões regulares.

2026-04-11 Usar esta ferramenta

Como resolver "invalid regular expression" e erros comuns de Regex: Um Guia Completo

Expressões Regulares (Regex) são incrivelmente poderosas para correspondência de padrões e manipulação de texto. No entanto, elas também são notórias por sua sintaxe densa e mensagens de erro crípticas. Um pequeno erro de digitação pode levar a um erro invalid regular expression que interrompe seu código.

Neste guia, vamos detalhar os erros de Regex mais comuns, explicar por que eles acontecem e mostrar como corrigi-los de forma eficiente.

1. Mensagens de erro comuns de Regex

Dependendo do seu ambiente, você pode encontrar estes erros:

  • JavaScript (RegExp): SyntaxError: Invalid regular expression: ...
  • Python (re): re.error: ...
  • Java: java.util.regex.PatternSyntaxException: ...
  • C#: System.ArgumentException: ...

2. Principais erros de sintaxis e soluções

2.1 "unterminated character class" (classe de caracteres não terminada)

Isso ocorre quando você abre uma classe de caracteres com [ mas esquece de fechá-la com ].

O erro:

const regex = /[a-z/  // SyntaxError: Invalid regular expression: /[a-z/: unterminated character class

A solução: Certifique-se de que cada [ tenha um ] correspondente.

const regex = /[a-z]/ // Correto

2.2 "invalid group" ou "unterminated group" (grupo não terminado)

Semelhante às classes de caracteres, isso acontece quando os parênteses () não estão equilibrados.

O erro:

const regex = /(abc/  // SyntaxError: Invalid regular expression: /(abc/: unterminated group

A solução: Equilibre seus parênteses.

const regex = /(abc)/ // Correto

2.3 "regex lookahead not supported" (lookahead não suportado)

Alguns mecanismos de Regex antigos ou implementações específicas não suportam recursos avançados como "lookahead" ((?=...)) ou "lookbehind" ((?<=...)).

O erro: regex lookahead not supported (comum em certos sistemas legados ou analisadores simples)

A solução: Verifique se o seu ambiente suporta esses recursos. No JavaScript, o lookbehind só foi adicionado no ES2018. Se precisar de compatibilidade, pode ser necessário refatorar sua regex para evitar estas construções.

3. Erros de desempenho e tempo de execução

3.1 "regex catastrophic backtracking" (retrocesso catastrófico)

Este é um dos erros de Regex mais perigosos. Acontece quando uma regex complexa com quantificadores aninhados (como (a+)+) encontra uma string que quase corresponde, mas falha no final. O mecanismo tenta milhares de combinações, fazendo com que a CPU suba para 100% e o aplicativo trave.

O sintoma: Seu código congela ou leva vários segundos para processar uma string pequena.

A solução:

  1. Evite quantificadores aninhados: Nunca aninhe *, + ou {n,} um dentro do outro.
  2. Seja específico: Em vez de .*, use classes de caracteres mais específicas como [^"\n]*.
  3. Use Grupos Atómicos: (Se suportado pelo seu mecanismo) para evitar que o mecanismo tente novamente caminhos que falharam.

3.2 "regex timeout" (tempo de execução esgotado)

Muitas plataformas modernas (como Cloudflare, mecanismos de banco de dados ou IDEs online) impõem um tempo limite estrito na execução de Regex para evitar o retrocesso catastrófico.

O erro: regex timeout

A solução: Otimize sua regex para desempenho. Divida padrões complexos em verificações menores e mais simples, ou use métodos de string (como indexOf ou startsWith) para correspondências básicas antes de aplicar uma regex.

4. Prevenção e melhores práticas

  1. Use a flag v (JavaScript): No JS moderno, a flag v oferece melhor suporte para Unicode e verificação de erros mais robusta.
  2. Teste incrementalmente: Não escreva uma regex gigante de uma só vez. Construa-a peça por peça e teste cada parte.
  3. Escape: Lembre-se sempre de escapar caracteres especiais como ., *, +, ?, ^, $, (, ), [, ], {, }, |, \ quando quiser correspondê-los literalmente.
  4. Use um Try-Catch: Se você estiver gerando uma regex a partir da entrada do usuário, use sempre um bloco try-catch.
function createSafeRegex(pattern) {
  try {
    return new RegExp(pattern);
  } catch (e) {
    console.error("Regex de usuário inválida:", e.message);
    return null;
  }
}

5. FAQ: Perguntas frequentes

P: Por que preciso escapar a barra frontal / no JavaScript?

R: Porque o JavaScript usa / como delimitador para literais de regex (ex: /padrão/). Se o seu padrão contiver uma /, você deve escrever \/. Alternativamente, use o construtor new RegExp("padrão") onde a / não precisa de escape.

P: Qual é a diferença entre .* e .*??

R: .* é ganancioso (greedy - corresponde ao máximo possível), enquanto .*? é preguiçoso (lazy - corresponde ao mínimo possível). O uso de quantificadores preguiçosos pode ajudar a evitar problemas de retrocesso.

P: Posso usar Regex para analisar HTML?

R: Geralmente, não. O HTML não é uma linguagem "regular"; é uma linguagem livre de contexto. Usar Regex para analisar HTML complexo é propenso a erros e leva ao retrocesso catastrófico. Use um analisador DOM adequado em seu lugar.

6. Ferramenta de verificação rápida

Lutando com uma regex que simplesmente não funciona? Use nosso Testador e Depurador de Regex Online. Ele oferece:

  • Correspondência em tempo real enquanto você digita.
  • Explicações detalhadas de cada parte da sua regex.
  • Detecção de retrocesso (backtracking) para alertá-lo sobre problemas de desempenho.
  • Geração de código para várias linguagens de programação.

Erros relacionados

  • Como resolver erros de 'Unexpected token in JSON'
  • Como corrigir 'URIError: URI malformed' no JavaScript
  • Como resolver erros de 'invalid base64 string'
Voltar ao blog Testador de Regex →