panic! es el mecanismo que utiliza Rust para manejar errores irrecupérables. Cuando un programa encuentra una situación en la que no puede continuar de forma segura, lanza un “pánico”. Esto provoca que el hilo actual se detenga, se imprima un mensaje de error en la consola y, si es necesario, se muestre el stack trace (rastreo de la pila de llamadas) para ayudar al programador a encontrar el fallo. El proceso completo termina o, en casos específicos, solo muere el hilo donde ocurrió el error.

Existen tres formas comunes de activar un pánico de manera condicional: unwrap(), que extrae el valor de un Option o Result o falla si el valor es incorrecto; expect(), que hace lo mismo pero permite añadir un mensaje personalizado para facilitar la depuración; y el macro panic! propiamente dicho.

Es fundamental saber cuándo es apropiado usar panic!. Debes usarlo únicamente cuando se viola una “invariante” del programa; es decir, cuando ocurre algo que, según la lógica de tu código, nunca debería suceder jamás (como un error de lógica interna o un bug). Por ejemplo, si una función recibe un índice que ya has verificado que está dentro de los límites, pero por algún error de cálculo llegas a un índice inválido, el panic! es apropiado. También es común en prototipos rápidos, pruebas unitarias o cuando quieres que el programa falle inmediatamente ante un estado inconsistente.

Por el contrario, un error muy común en principiantes es usar panic! (o unwrap()) para manejar errores esperables. Si una función lee un archivo y el archivo no existe, o si un usuario ingresa una letra donde se esperaba un número, no debes usar panic!. En esos casos, el programa debe devolver un Result para que el llamador pueda decidir cómo recuperarse (por ejemplo, pidiendo el dato de nuevo). Si usas panic! para errores de entrada de usuario o de red, tu aplicación será extremadamente frágil y se cerrará ante cualquier inconveniente externo.

// Función que ilustra una violación de invariante lógica
fn dividir_con_seguridad(numerador: i32, denominador: i32) -> i32 {
    if denominador == 0 {
        // Usamos panic! porque dividir por cero en esta lógica es un error crítico de diseño
        panic!("Error fatal: Se intentó dividir por cero en la operación aritmética.");
    }
    numerador / denominador
}

fn main() {
    let a = 10;
    let b = 2;

    // 1. Uso normal: El cálculo es correcto
    let resultado = dividir_con_seguridad(a, b);
    println!("Resultado de la división: {}", resultado);

    // 2. Uso de .expect(): Desempaqueta un Option o lanza pánico con mensaje personalizado
    // Es preferible a .unwrap() porque ayuda a identificar el error en los logs
    let opcion_nombre: Option<String> = Some("Rust".to_string());
    let nombre = opcion_nombre.expect("El nombre debería estar presente en este flujo");
    println!("Nombre encontrado: {}", nombre);

    // 3. Uso de .unwrap(): Desempaqueta de forma directa (más arriesgado)
    let opcion_numero: Option<i32> = Some(42);
    let numero = opcion_numero.unwrap();
    println!("Número extraído: {}", numero);

    // 4. Ejemplo de error esperado (Comentado para que el código compile y corra)
    // Si descomentamos la siguiente línea, el programa lanzará un panic y se detendrá.
    // let error_critico = dividir_con_seguridad(10, 0);
    // println!("{}", error_critico);
}

Análisis de código

  • dividir_con_seguridad(numerador: i32, denominador: i32) -> i32: Esta función recibe dos enteros de 32 bits y devuelve un entero. Si el denominador es 0, ejecuta el macro panic!, deteniendo el hilo con un mensaje de error.
  • let a = 10; y let b = 2;: Se definen variables enteras para realizar una división exitosa.
  • let resultado = dividir_con_seguridad(a, b);: Llama a la función con valores válidos, permitiendo que el programa continúe.
  • opcion_nombre.expect("..."): Se aplica sobre un tipo Option<String>. Si opcion_nombre fuera None, el programa lanzaría un pánico con el mensaje proporcionado. Como es Some, extrae el String.
  • opcion_numero.unwrap(): Similar a expect, pero si opcion_numero fuera None, el programa fallaría sin un mensaje personalizado, simplemente con el mensaje por defecto de Rust.
  • La línea comentada en main: Representa un caso donde la lógica fallaría. Si se ejecutara dividir_con_seguridad(10, 0), el programa imprimiría el mensaje de error definido en el panic! y terminaría su ejecución antes de llegar al println! final.

N° 60