Expresiones regulares en Rust: guía completa con ejemplos

Expresiones regulares en Rust: una herramienta poderosa para trabajar con cadenas

Las expresiones regulares (regex) son una herramienta indispensable para buscar, extraer y reemplazar texto según un patrón determinado. En Rust, el trabajo con expresiones regulares se implementa a través del popular crate regex, que proporciona alto rendimiento y seguridad, características del lenguaje. En este artículo, analizaremos los conceptos básicos del trabajo con expresiones regulares en Rust con ejemplos concretos.

Instalación y configuración del crate regex

Para comenzar, agregue la dependencia en el archivo Cargo.toml de su proyecto:

[dependencies]regex = "1"

Luego, importe los módulos necesarios en el código:

use regex::Regex;

Creación y uso básico de expresiones regulares

El tipo principal para trabajar con expresiones regulares es Regex. Se crea mediante el método Regex::new(), que toma una cadena con el patrón y devuelve un Result. Veamos un ejemplo simple de búsqueda de una palabra en una cadena:

use regex::Regex;

fn main() {    let re = Regex::new(r"hello").unwrap();    let text = "hello world, hello Rust!";        // Verificar si hay coincidencia    if re.is_match(text) {        println!("¡Coincidencia encontrada!");    }        // Buscar la primera coincidencia    match re.find(text) {        Some(mat) => println!("Encontrado: '{}'", mat.as_str()),        None => println!("No hay coincidencias"),    }        // Buscar todas las coincidencias    for mat in re.find_iter(text) {        println!("Encontrado: '{}' en la posición {}", mat.as_str(), mat.start());    }}

Observe el uso de la cadena raw (r"..."). Esto permite evitar el escape de barras invertidas, lo que es especialmente conveniente al trabajar con expresiones regulares.

Grupos de captura y extracción de datos

Los grupos de captura permiten extraer partes de una cadena que coinciden con partes específicas del patrón. En Rust, los grupos se indican con paréntesis ():

use regex::Regex;

fn main() {    // Extraer fecha en formato AAAA-MM-DD    let re = Regex::new(r"(\\d{4})-(\\d{2})-(\\d{2})").unwrap();    let text = "Hoy: 2024-01-15, ayer: 2024-01-14";        for cap in re.captures_iter(text) {        println!("Año: {}, Mes: {}, Día: {}",                  &cap[1], &cap[2], &cap[3]);    }        // Extraer direcciones de email    let email_re = Regex::new(r"([\\w.]+)@([\\w.]+)").unwrap();    let email_text = "Contactos: user@example.com, admin@test.org";        if let Some(caps) = email_re.captures(email_text) {        println!("Nombre de usuario: {}", &caps[1]);        println!("Dominio: {}", &caps[2]);    }}

Los grupos se pueden nombrar para mejorar la legibilidad del código:

use regex::Regex;

fn main() {    let re = Regex::new(r"(?P<year>\\d{4})-(?P<month>\\d{2})-(?P<day>\\d{2})").unwrap();    let text = "2024-01-15";        if let Some(caps) = re.captures(text) {        println!("Año: {}", caps.name("year").unwrap().as_str());        println!("Mes: {}", caps.name("month").unwrap().as_str());        println!("Día: {}", caps.name("day").unwrap().as_str());    }}

Reemplazo de texto con expresiones regulares

El crate regex proporciona métodos potentes para reemplazar texto. Veamos varias opciones:

use regex::Regex;

fn main() {    let re = Regex::new(r"\\d+").unwrap();    let text = "Tengo 2 gatos y 3 perros";        // Reemplazo simple de todos los dígitos por una palabra    let result = re.replace_all(text, "varios");    println!("{}", result); // "Tengo varios gatos y varios perros"        // Reemplazo usando grupos de captura    let re2 = Regex::new(r"(\\w+)@(\\w+)").unwrap();    let email = "user@example.com";    let replaced = re2.rep
```