Expressões Regulares em Rust: Guia Completo com Exemplos

Introdução: Expressões Regulares em Rust — uma ferramenta poderosa para processamento de texto

Expressões regulares (regex) são uma parte essencial do arsenal de qualquer desenvolvedor que trabalha com texto. Em Rust, conhecido por seu desempenho e segurança, o trabalho com expressões regulares é implementado através do popular crate regex. Esta biblioteca fornece uma maneira rápida e confiável de pesquisar, extrair e substituir padrões de texto.

Neste artigo, vamos detalhar como usar expressões regulares em Rust: desde a instalação do crate até técnicas avançadas. Você aprenderá como verificar correspondências, extrair dados, substituir texto e tratar erros. Todos os exemplos de código estão escritos em Rust e prontos para uso.

1. Instalação e inclusão do crate regex

Para trabalhar com expressões regulares em Rust, é necessário adicionar o crate regex ao arquivo Cargo.toml:

[dependencies]regex = "1"

Depois disso, você pode importar os módulos necessários no código:

use regex::Regex;

O crate regex compila automaticamente as expressões regulares em um formato interno eficiente, garantindo alta velocidade de execução.

2. Operações básicas com regex em Rust

2.1 Verificação de correspondência (is_match)

O método is_match retorna true se a string contiver pelo menos uma correspondência com o padrão:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Hoje é 25 de dezembro";

    if re.is_match(text) {        println!("A string contém números");    } else {        println!("Números não encontrados");    }}

Este método é útil para validação rápida: verificar se a string contém email, telefone ou outros padrões.

2.2 Busca da primeira correspondência (find)

O método find retorna a primeira correspondência como uma estrutura Match, que contém o início e o fim da correspondência:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\b\\w+@\\w+\\.\\w+\\b").unwrap();    let text = "Meu email: user@example.com, e também admin@test.org";

    if let Some(mat) = re.find(text) {        println!("Email encontrado: {}", mat.as_str());        println!("Posição: {}..{}", mat.start(), mat.end());    }}

Resultado da execução:

Email encontrado: user@example.comPosição: 11..27

2.3 Busca de todas as correspondências (find_iter)

Para obter todas as correspondências, usa-se o iterador find_iter:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Preços: 100, 250 e 500 reais";

    for mat in re.find_iter(text) {        println!("Número: {}", mat.as_str());    }}

Saída:

Número: 100Número: 250Número: 500

3. Extração de grupos usando parênteses de captura

Uma das capacidades mais poderosas do regex são os grupos de captura. Eles permitem extrair partes da correspondência:

use regex::Regex;

fn main() {    let re = Regex::new(r"(\\w+)@(\\w+)\\.(\\w+)").unwrap();    let text = "user@example.com";

    if let Some(caps) = re.captures(text) {        println!("Email completo: {}", &caps[0]);        println!("Nome de usuário: {}", &caps[1]);        println!("Domínio: {}", &caps[2]);        println!("Zona: {}", &caps[3]);    }}

Os grupos são numerados a partir de 1. O grupo 0 é toda a correspondência completa.

Também é possível usar grupos nomeados para um código mais legível:

use regex::Regex;

fn main() {    let re = Regex::new(r"(?P<name>\\w+)@(?P<domain>\\w+\\.\\w+)").unwrap();    let text = "admin@test.org";

    if let Some(caps) = re.captures(text) {        println!("Nome: {}", caps.name("name").unwrap().as_str
```