22 - Implementación de manejo de errores robusto en Rust

22 - Implementación de manejo de errores robusto en Rust

El manejo de errores en Rust es una de sus fortalezas principales, ya que permite escribir código seguro y confiable sin comprometer el rendimiento. Para lograr un manejo de errores robusto, debemos combinar el uso adecuado de Result<T, E>, Option<T>, el operador ?, panic! y estrategias para registrar y manejar errores de manera efectiva. En este artículo, exploraremos técnicas avanzadas de manejo de errores aplicadas al mundo Pokémon.

Estrategias clave para un manejo de errores robusto #

El manejo de errores en Rust se puede dividir en tres categorías principales:

  1. Errores recuperables: Representados con Result<T, E>, estos errores pueden manejarse en tiempo de ejecución sin detener el programa.
  2. Errores irreversibles: panic! se usa cuando el programa no puede continuar de manera segura.
  3. Errores con información detallada: Implementación de thiserror o anyhow para mejorar la trazabilidad y depuración de errores.

Uso correcto de result<t, e> para manejar errores recuperables #

El tipo Result<T, E> nos permite manejar errores de manera explícita y decidir si queremos recuperarnos de ellos o propagarlos.

Ejemplo: intentando capturar un pokémon # 

enum ErrorCaptura {
    SinPokeballs,
    ElementoHuyo,
}

fn intentar_captura(pokeballs: u8) -> Result<&'static str, ErrorCaptura> {
    if pokeballs == 0 {
        return Err(ErrorCaptura::SinPokeballs);
    }
    
    let probabilidad_huida = 0.3;
    if rand::random::<f32>() < probabilidad_huida {
        return Err(ErrorCaptura::ElementoHuyo);
    }
    
    Ok("¡Has capturado al Pokémon!")
}

fn main() {
    match intentar_captura(1) {
        Ok(mensaje) => println!("{}", mensaje),
        Err(ErrorCaptura::SinPokeballs) => println!("No tienes Poké Balls disponibles."),
        Err(ErrorCaptura::ElementoHuyo) => println!("El Pokémon ha huido."),
    }
}

📌 Consejos:

  • Usa Result<T, E> cuando el error pueda ser manejado en tiempo de ejecución.
  • Diferencia errores con enum para proporcionar mensajes de error más significativos.

Evitando panic! en código de producción #

La macro panic! se debe usar solo en casos donde el error sea crítico e irrecuperable.

Ejemplo incorrecto: # 

fn obtener_elemento_en_equipo(index: usize, equipo: Vec<String>) -> String {
    equipo.get(index).unwrap().to_string()
}

Si el índice no es válido, el programa entrará en panic! y se detendrá abruptamente. En su lugar, podemos manejar el error de forma segura con Option<T>.

Solución correcta con option<t>: # 

fn obtener_elemento_en_equipo(index: usize, equipo: Vec<String>) -> Option<String> {
    equipo.get(index).cloned()
}

fn main() {
    let equipo = vec!["Item1".to_string(), "Charizard".to_string()];
    match obtener_elemento_en_equipo(2, equipo) {
        Some(pokemon) => println!("El Pokémon en la posición seleccionada es {}.", pokemon),
        None => println!("No hay un Pokémon en esa posición."),
    }
}

📌 Consejos:

  • Usa Option<T> para representar valores opcionales en lugar de usar unwrap(), que puede causar fallos inesperados.
  • En código de producción, evita panic! a menos que sea estrictamente necesario.

Propagación de errores con ? #

El operador ? simplifica la propagación de errores sin necesidad de escribir múltiples estructuras match.

Ejemplo: leer un archivo con información de un pokémon # 

use std::fs;
use std::io::{self, Read};

fn leer_pokedex(nombre_archivo: &str) -> Result<String, io::Error> {
    let mut archivo = fs::File::open(nombre_archivo)?;
    let mut contenido = String::new();
    archivo.read_to_string(&mut contenido)?;
    Ok(contenido)
}

fn main() {
    match leer_pokedex("pokedex.txt") {
        Ok(datos) => println!("Información de la Pokédex: {}", datos),
        Err(e) => println!("Error al leer la Pokédex: {}", e),
    }
}

📌 Consejos:

  • Usa ? cuando trabajes con Result<T, E> para evitar código repetitivo.
  • Solo úsalo en funciones que retornen Result<T, E>.

Uso de thiserror y anyhow para errores más informativos #

Para mejorar la trazabilidad y el reporte de errores, podemos utilizar la crate thiserror para definir errores personalizados y anyhow para manejar errores dinámicos.

Ejemplo con thiserror # 

use thiserror::Error;

#[Derive(debug, error)]
enum ErrorPokedex {
    #[error("No se pudo abrir el archivo: {0}")]
    ArchivoInaccesible(std::io::Error),
    #[error("El formato del archivo es inválido")]
    FormatoInvalido,
}

fn leer_pokedex(nombre: &str) -> Result<String, ErrorPokedex> {
    let contenido = std::fs::read_to_string(nombre).map_err(ErrorPokedex::ArchivoInaccesible)?;
    if contenido.is_empty() {
        return Err(ErrorPokedex::FormatoInvalido);
    }
    Ok(contenido)
}

📌 Beneficios de thiserror:

  • Define errores personalizados con descripciones claras.
  • Permite usar map_err para convertir errores en variantes de enum fácilmente.

Conclusión #

Para implementar un manejo de errores robusto en Rust:

  • Usa Result<T, E> para manejar errores recuperables.
  • Evita panic! en código de producción y utiliza Option<T> cuando sea necesario.
  • Propaga errores de manera eficiente con ? para reducir la redundancia.
  • Implementa thiserror o anyhow para mejorar la trazabilidad y reporte de errores.

Con estas estrategias, podemos escribir aplicaciones en Rust más seguras y resilientes.