1. Fundamentos das Expressões Regulares

Expressões regulares são padrões usados para buscar, casar e manipular strings. Elas combinam literais com metacaracteres que definem regras de formato. Entre os principais conceitos estão:

• Literais: correspondem exatamente ao caractere ou sequência. Ex.: cat casa com “cat”.
• Metacaracteres básicos: . (qualquer caractere), ^ (início), $ (fim), *, +, ? (quantificadores).
• Classes de caracteres: [abc], [^abc], \\d (dígitos), \\w (palavras), \\s (espaços).
• Grupos: parênteses definem captura; (?: ... ) cria grupo não capturante.
• Flags: i (ignore case), g (global), m (multiline), s (dotall), u (unicode).

Exemplo simples (JS/PCRE): casar datas no formato dd/mm/yyyy com validação básica de dígitos:

const re = /^(?:0[1-9]|[12][0-9]|3[01])\/(?:0[1-9]|1[0-2])\/(?:19|20)\d{2}$/;

2. Construção de Padrões Eficazes

Projete padrões de forma clara, priorizando legibilidade e desempenho. Use grupos com objetivo explícito e evite captura desnecessária. Exemplos úteis:

• Valores opcionalmente associados: coluna(?:\\s*-\\s*valor)?
• Grupo não capturante para evitar overhead: (?:http|https)://
• Aferição de formatos simples: ^\\d{3}-\\d{2}-\\d{4}$ (ex.: CPF/ID simplificado).

Exemplos práticos de padrões comuns:

// Validação básica de e-mail (relação simples, não exaustiva)
const email = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[A-Za-z]{2,}$/;

// Extração de URL simples
const url = /https?:\\/\\/(?:www\\.)?[\\w.-]+(?:\\/[\\w./-]*)?/g;

Notas de portabilidade:

• Lookarounds (?=, (?!)) são úteis para checagem sem consumir caracteres; alguns ambientes possuem suporte limitado.
• Named capture (ex.: (?\\d{2})) facilita leitura, disponível em engines modernos (JS com ES2018+, PCRE, etc.).

3. Diagnóstico e Performance

Regex pode ser poderoso, mas pode se tornar um gargalo. Dicas rápidas para evitar armadilhas comuns:

• Atenção a backtracking excessivo com padrões ambíguos como (a+)+ em entradas longas.
• Prefira quantificadores não preguiçosos quando apropriado e use âncoras para restringir o escopo de busca.
• Quando disponível, utilize grupos não capturantes e minimize capturas desnecessárias para reduzir overhead.
• Considere engines com suporte a lookbehind ou atomic groups apenas quando necessário e garantida compatibilidade.

Exemplo de situação problemática e alternativa segura:

// Problemático em algumas entradas longas (backtracking explosivo)
const problematic = /^(a+)+$/;

// Alternativa mais estável (evita backtracking desnecessário)
const stable = /^(?:a+)+$/; // ainda pode haver casos, mas é mais previsível em certain engines

4. Casos Práticos e Padrões Úteis

Abaixo estão padrões com uso comum em validação e extração. Adapte conforme o motor de regex da sua linguagem.

• CEP brasileiro (formato 99999-999): ^\\d{5}-?\\d{3}$
• CPF simples (formato 000.000.000-00) — validação básica: ^\\d{3}\\.\\d{3}\\.\\d{3}-\\d{2}$
• Telefone brasileiro (com ou sem código DDD): ^\\(\\d{2}\\)\\s?\\d{4,5}-\\d{4}$
• Data no formato dd/mm/yyyy (validação básica): ^(0?[1-9]|[12][0-9]|3[01])/ (0?[1-9]|1[0-2])/\\d{4}$
• URL simples (http/https): https?:\\/\\/(?:www\\.)?[\\w.-]+(?:\\/[\\w./-]*)?
• Texto entre aspas simples ou duplas (captura opcional): ["']([^"']+)["']

Bloco de código útil para uso cotidiano:

// Escapar uma string para uso seguro em regex
function escapeRegex(text) {
  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');
}

// Uso seguro para validar entrada de usuário contra um padrão existente
const raw = "(exemplo) de entrada";
const pattern = new RegExp('^' + escapeRegex(raw) + '$');