Equivalente de la instrucción Try-Catch en Rust

Rust es un lenguaje de programación que proporciona una forma más segura y confiable de desarrollar software. Está diseñado para evitar errores comunes que conducen a vulnerabilidades de seguridad en otros idiomas.

El lenguaje Rust no admite el manejo de excepciones, lo que significa que no tiene una declaración try-catch en Rust.

La falta de manejo de excepciones en Rust elimina la posibilidad de errores de tiempo de ejecución debido a excepciones lanzadas desde una función. Esto se debe a que el programa se detendrá en el punto donde ocurra un error en lugar de continuar y posiblemente causar otros problemas en el código base.

Este artículo discutirá el equivalente de Rust a una declaración try-catch.

Equivalente de la instrucción try-catch en Rust

Hay muchos equivalentes disponibles en Rust para declaraciones try-catch. Pero, aquí en este artículo, discutiremos solo algunos equivalentes más cercanos.

Utilizar el ? Operador en Rust

En Rust, podemos usar el ? operador para devolver o no devolver los valores.

Los ? operator es una de las características esenciales de Rust, y se puede utilizar de muchas maneras diferentes. Puede verificar si un valor está presente, si se ha asignado un valor a una variable o si una expresión se evalúa como verdadera o falsa.

Los ? El operador también se puede usar como una alternativa para la declaración try-catch de Rust. Los ? operador toma un cierre como su parámetro.

Luego, se puede llamar al cierre sin preocuparse por lo que sucederá si ocurre un error durante la ejecución.

Los ? El operador detectará el error y devolverá el valor del cierre si no hubo error, o devolverá un tipo de error con una descripción de lo que salió mal si hubo uno.

Ejemplo:

fn main() {
    let hello_tasks = || -> Result<(), HelloError> {
        hello_task_1()?;
        hello_task_2()?;
        hello_task_3()?;
        Ok(())
    };
    if let Err(_err) = hello_tasks() {
        println!("There's an error in your code, please correct it");
    }
}
enum HelloError {
    HelloTask1Error,
    HelloTask2Error,
    HelloTask3Error,
}
fn hello_task_1() -> Result<(), HelloError> {
    println!("Task No 1");
    Ok(())
}
fn hello_task_2() -> Result<(), HelloError> {
    println!("Task No 2");
    Err(HelloError::HelloTask2Error)
}
fn hello_task_3() -> Result<(), HelloError> {
    println!("task3");
    Ok(())
}

Producción :

Task No 1
Task No 2
There's an error in your code, please correct it

Haga clic aquí para ver la demostración en vivo del código mencionado anteriormente.