面试题：Rust Result类型的错误传播与处理策略

在Rust中，Result类型用于处理可能会出现错误的操作。Result类型有两个泛型参数：Ok(T)表示操作成功，其中T是成功时返回的值；Err(E)表示操作失败，其中E是错误类型。

当函数可能返回多种不同类型的错误时，可以使用From trait将不同的错误类型转换为一个统一的错误类型，然后在调用栈的合适位置进行处理。

以下是一个示例代码，展示了如何实现这一点：

use std::fmt;

// 定义不同模块中的错误类型
mod module1 {
    #[derive(Debug)]
    pub struct Error1;
    impl fmt::Display for Error1 {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "Error from module1")
        }
    }
}

mod module2 {
    #[derive(Debug)]
    pub struct Error2;
    impl fmt::Display for Error2 {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "Error from module2")
        }
    }
}

// 定义一个统一的错误类型
#[derive(Debug)]
enum AppError {
    Error1(module1::Error1),
    Error2(module2::Error2),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::Error1(e) => e.fmt(f),
            AppError::Error2(e) => e.fmt(f),
        }
    }
}

// 为不同的错误类型实现From trait，以便转换为统一的错误类型
impl From<module1::Error1> for AppError {
    fn from(e: module1::Error1) -> Self {
        AppError::Error1(e)
    }
}

impl From<module2::Error2> for AppError {
    fn from(e: module2::Error2) -> Self {
        AppError::Error2(e)
    }
}

// 定义可能返回不同错误类型的函数
fn function1() -> Result<i32, module1::Error1> {
    Err(module1::Error1)
}

fn function2() -> Result<i32, module2::Error2> {
    Err(module2::Error2)
}

// 组合函数，传播并统一错误
fn combined_function() -> Result<i32, AppError> {
    // 尝试调用function1，并将其错误转换为AppError
    let result1 = function1().map_err(|e| e.into());
    if result1.is_err() {
        return result1;
    }

    // 尝试调用function2，并将其错误转换为AppError
    let result2 = function2().map_err(|e| e.into());
    if result2.is_err() {
        return result2;
    }

    // 如果两个函数都成功，返回一个值
    Ok(42)
}

fn main() {
    match combined_function() {
        Ok(value) => println!("Success: {}", value),
        Err(e) => eprintln!("Error: {}", e),
    }
}

在上述代码中：

我们定义了两个来自不同模块的错误类型 Error1 和 Error2。
然后定义了一个统一的错误类型 AppError，并为其实现了 Display trait。
通过为 module1::Error1 和 module2::Error2 实现 From trait，将它们转换为 AppError。
function1 和 function2 是可能返回不同错误类型的函数。
combined_function 调用 function1 和 function2，并将它们的错误转换为统一的 AppError 类型进行传播。
在 main 函数中，通过 match 语句对 combined_function 的结果进行处理，统一处理所有可能的错误。

星途面试题库

面试题：Rust Result类型的错误传播与处理策略

知识考点

面试题答案