Manejo de errores con Box en Rust

RustRustBeginner
Practicar Ahora

This tutorial is from open-source community. Access the source code

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, el código demuestra cómo utilizar el tipo Box para preservar los errores originales al envolverlos, lo que permite un manejo dinámico de errores, y el trato From de la biblioteca Std ayuda a convertir cualquier tipo que implemente el trato Error en el objeto de trato Box<Error>. Incluye un ejemplo de conversión y manejo de errores utilizando Box con un tipo de error personalizado.

Nota: Si el laboratorio no especifica un nombre de archivo, puede utilizar cualquier nombre de archivo que desee. Por ejemplo, puede utilizar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/DataTypesGroup -.-> rust/string_type("String Type") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/AdvancedTopicsGroup -.-> rust/traits("Traits") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/integer_types -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/string_type -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/function_syntax -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/expressions_statements -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/method_syntax -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/traits -.-> lab-99248{{"Manejo de errores con Box en Rust"}} rust/operator_overloading -.-> lab-99248{{"Manejo de errores con Box en Rust"}} end

Empaquetar errores

Una forma de escribir código simple mientras se preservan los errores originales es empaquetarlos con Box. La desventaja es que el tipo de error subyacente solo es conocido en tiempo de ejecución y no se determina en tiempo de compilación.

La biblioteca estándar ayuda a empaquetar nuestros errores al hacer que Box implemente la conversión de cualquier tipo que implemente el trato Error al objeto de trato Box<Error>, a través de From.

use std::error;
use std::fmt;

// Cambia el alias a `Box<error::Error>`.
type Result<T> = std::result::Result<T, Box<dyn error::Error>>;

#[derive(Debug, Clone)]
struct EmptyVec;

impl fmt::Display for EmptyVec {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "invalid first item to double")
    }
}

impl error::Error for EmptyVec {}

fn double_first(vec: Vec<&str>) -> Result<i32> {
    vec.first()
     .ok_or_else(|| EmptyVec.into()) // Convierte a Box
     .and_then(|s| {
            s.parse::<i32>()
             .map_err(|e| e.into()) // Convierte a Box
             .map(|i| 2 * i)
        })
}

fn print(result: Result<i32>) {
    match result {
        Ok(n) => println!("The first doubled is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let numbers = vec!["42", "93", "18"];
    let empty = vec![];
    let strings = vec!["tofu", "93", "18"];

    print(double_first(numbers));
    print(double_first(empty));
    print(double_first(strings));
}

Resumen

¡Felicitaciones! Has completado el laboratorio de Empaquetar Errores con Box. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.