Validador de Regex Rust

A crate regex do Rust: tempo linear por design

A crate regex, escrita por Andrew Gallant (burntsushi), e a biblioteca padrão de fato para expressões regulares em Rust. Diferente da PCRE, PCRE2, do re do Python ou do java.util.regex, a crate Rust garante casamento em tempo linear no tamanho da entrada. Não ha recursao, não ha backtracking e, portanto, não ha superfície de ataque ReDoS — a mesma propriedade que permite ao ripgrep (também do burntsushi) varrer gigabytes de código em segundos.

O trade-off e paridade de features. Para manter linearidade, a crate omite deliberadamente os dois recursos mais associados a backtracking catastrofico: backreferences (\1, \2) e lookarounds ((?=...), (?!...), (?<=...), (?<!...)). Se você precisa, a crate irma fancy-regex envelopa a regex e cai num motor com backtracking — ao custo da garantia linear.

Interna do motor: DFA preguicoso sobre NFA Pike VM

A crate compila o padrão em uma NFA (Pike VM) e, durante o casamento, constroi sob demanda um DFA preguicoso — so os estados realmente visitados são materializados, mantendo a memória limitada. Em cargas predominantemente ASCII o runtime ainda despacha para memchr, aho-corasick (multipadrao), boyer-moore e scanners literais acelerados por SIMD. Esta abordagem hibrida e por que o ripgrep bate o GNU grep e o silver searcher em árvores grandes de código.

Na pratica, Regex::new("foo") pode levar dezenas de microssegundos porque constroi o automato. Para uso repetido, cacheie regex compilados com once_cell::sync::Lazy ou com o macro mais antigo lazy_static! — nunca compile dentro de um loop quente.

Sintaxe suportada: Unicode-first, compatível com RE2

A gramatica e intencionalmente próxima a do regexp do Go e do RE2 do Google, com extensões:

• Classes de caracteres: [a-z], negacao [^0-9], intersecao e subtracao dentro de [...].
• Categorias Unicode: \p{Greek}, \p{Letter}, \p{Decimal_Number} — Unicode 15 por padrão.
• Grupos nomeados: (?P<year>\d{4}), recuperado via .name("year").
• Flags: (?i) case-insensitive, (?m) multiline, (?s) ponto casa newline, (?x) extended (ignora whitespace).
• Quantificadores: gulosos */+/?, lazy *?/+?/??, limitados {n,m}.
• Ancoras: ^, $, \b fronteira de palavra, \A / \z início/fim absolutos.

Performance vs PCRE2, Python e Hyperscan

Benchmarks independentes (rebar, também do burntsushi) classificam os motores aproximadamente assim em cargas gerais: Hyperscan (Intel) ≈ Rust regex > Go regexp > PCRE2-JIT > PCRE2 > Python re > Ruby Onigmo. O Hyperscan e mais rápido em cenários multi-padrão específicos (IDS de rede); o Rust ganha em busca de código genérica. O PCRE2 ganha em quantidade de features.

Um anti-padrão clássico que destroi motores com backtracking e a quantificacao aninhada como (a+)+$ ou (.*)*. Sobre 30 caracteres de "aaaaaa..." seguidos de "b", a PCRE explode em milhões de passos; a crate Rust termina em microssegundos porque o DFA visita cada caractere no máximo uma vez.

Uso idiomatico e ecossistema

use once_cell::sync::Lazy;
use regex::Regex;

static RE: Lazy<Regex> = Lazy::new(|| {
    Regex::new(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})").unwrap()
});

fn parse(s: &str) -> Option<(&str, &str, &str)> {
    let c = RE.captures(s)?;
    Some((c.name("y")?.as_str(),
          c.name("m")?.as_str(),
          c.name("d")?.as_str()))
}

Casos onde a garantia linear brilha: parsing de logs a milhões de linhas/seg, syntax highlighting em editores (Helix, Zed), busca de código (ripgrep, fd), roteadores HTTP (o actix-web usa regex para parâmetros de path) e qualquer serviço que aceite padrões do usuário — expor PCRE2 a entrada não confiável e um vetor conhecido de DoS.

Testes e ferramentas

• rustexp (rustexp.lpil.uk) — playground com pegada oficial para a crate Rust.
• regex101 com sabor Rust — explicacao interativa, mas atenção: a sintaxe de lookaround aparece como suportada porque o site cai na PCRE.
• cargo test — escreva testes unitarios afirmando casamentos positivos e negativos; a crate e determinística e reproduzivel entre plataformas.
• crate regex-syntax — API somente de parsing para validar um padrão em tempo de compilacao ou em build scripts.

FAQ

A regex do Rust suporta backreferences?

Não. A crate principal recusa padrões com \1, \2 etc. porque exigem backtracking. Se precisar, use a crate fancy-regex, que envelopa a regex e cai num motor com backtracking quando o padrão demanda.

A crate e imune a ReDoS?

Sim. O casamento e linear no tamanho da entrada e a memória do DFA preguicoso e limitada (e configuravel). Padrões que paralisam a PCRE — como (a+)+$ — terminam em microssegundos.

Como se compara com a PCRE2?

A PCRE2 tem toda feature ja inventada (lookarounds, backreferences, subrotinas, recursao) e o PCRE2-JIT e rápido. A crate Rust abre mão dessas features em troca de segurança em tempo linear e scan literal por SIMD. Escolha PCRE2 por expressividade, Rust por segurança e busca de código.

Da para usar o mesmo padrão em Go e Rust?

Em geral sim — ambos implementam sintaxe RE2. O Rust adiciona classes de propriedade Unicode e algumas flags extras que faltam no Go, mas o subconjunto comum transfere limpo.

Por que meu regex Rust e lento na primeira chamada?

Regex::new() constroi o automato. Tire a compilacao de loops quentes usando once_cell::sync::Lazy. Em regime, o DFA preguicoso esta entre os motores mais rapidos disponíveis.