Rust 错误处理：Result 类型与 ? 运算符

Rust 不使用异常机制处理错误，而是通过类型系统强制你在编译期就考虑所有可能的失败情况。核心工具是 Result<T, E> 枚举和 ? 运算符。掌握它们，你就能写出既安全又简洁的错误处理代码。

理解 Result 类型

定义你的函数返回 Result<T, E>，表示它要么成功返回类型 T 的值（用 Ok(T) 包装），要么失败并返回类型 E 的错误信息（用 Err(E) 包装）。

例如，一个尝试将字符串转为整数的函数：

fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

调用这个函数后，你必须显式处理两种可能的结果：

1. 使用 match 手动分支处理：

   let result = parse_number("42");
   match result {
       Ok(num) => println!("成功: {}", num),
       Err(e) => println!("失败: {}", e),
   }

2. 使用 unwrap() 或 expect() 快速获取成功值（仅用于原型或确定不会失败的场景）：

   • unwrap()：失败时程序 panic。
   • expect("自定义消息")：失败时 panic 并显示你的消息。

     let num = parse_number("42").unwrap(); // 如果输入是 "abc"，这里会崩溃

使用 ? 运算符简化错误传播

当你在函数内部调用另一个返回 Result 的函数，并希望在出错时直接将错误返回给上层调用者，? 运算符能极大简化代码。

替换冗长的 match 语句：

// 不用 ? 的写法
fn read_config() -> Result<String, std::io::Error> {
    let file = File::open("config.txt");
    let mut file = match file {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    let mut contents = String::new();
    match file.read_to_string(&mut contents) {
        Ok(_) => Ok(contents),
        Err(e) => Err(e),
    }
}

// 使用 ? 的写法
fn read_config() -> Result<String, std::io::Error> {
    let mut file = File::open("config.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

注意：? 只能在返回 Result（或 Option）的函数中使用。它会自动将 Err(e) 转换为当前函数的返回值。

处理不同错误类型的转换

当函数内部调用多个可能返回不同类型错误的函数时，? 无法直接工作，因为 Rust 要求整个函数的 Result 错误类型 E 必须统一。

解决方案：定义自己的错误类型，或使用通用错误库如 anyhow。

方法一：手动实现 From trait 进行转换

假设你的函数同时涉及文件操作（std::io::Error）和数字解析（std::num::ParseIntError）：

1. 定义一个枚举包含所有可能的错误：

   #[derive(Debug)]
   enum MyError {
       Io(std::io::Error),
       Parse(std::num::ParseIntError),
   }

2. 实现 From trait 让 ? 能自动转换：

   impl From<std::io::Error> for MyError {
       fn from(error: std::io::Error) -> Self {
           MyError::Io(error)
       }
   }
   
   impl From<std::num::ParseIntError> for MyError {
       fn from(error: std::num::ParseIntError) -> Self {
           MyError::Parse(error)
       }
   }

3. 编写函数并使用 ?：

   use std::fs::File;
   use std::io::Read;
   
   fn process_file() -> Result<i32, MyError> {
       let mut file = File::open("data.txt")?; // 自动转为 MyError::Io
       let mut contents = String::new();
       file.read_to_string(&mut contents)?;
       let number = contents.trim().parse::<i32>()?; // 自动转为 MyError::Parse
       Ok(number)
   }

方法二：使用 anyhow 库（推荐用于应用层）

对于非库代码（如命令行工具、Web 服务），使用 anyhow::Result 更简单：

1. 添加依赖到 Cargo.toml：

   [dependencies]
   anyhow = "1.0"

2. 直接使用 anyhow::Result 作为返回类型：

   use anyhow::Result;
   use std::fs::File;
   use std::io::Read;
   
   fn process_file() -> Result<i32> {
       let mut file = File::open("data.txt")?;
       let mut contents = String::new();
       file.read_to_string(&mut contents)?;
       let number = contents.trim().parse::<i32>()?;
       Ok(number)
   }

   anyhow 自动处理不同错误类型的转换，并支持添加上下文信息（如 .context("读取配置文件失败")?）。

高级技巧：组合 Result 和 Option

有时你需要将 Option 转换为 Result，或反之。

• 将 Option 转为 Result：使用 ok_or() 或 ok_or_else()。

  let opt = Some(42);
  let res: Result<i32, &str> = opt.ok_or("没有值");

• 在 Result 中处理 Option：使用 ? 后接 ok_or()。

  fn get_first_char(s: &str) -> Result<char, &str> {
      s.chars().next().ok_or("字符串为空")
  }

• 将 Result 转为 Option：使用 ok()（丢弃错误信息）。

  let res: Result<i32, _> = "42".parse();
  let opt: Option<i32> = res.ok(); // 成功则 Some(42)，失败则 None

最佳实践总结

始终让错误处理代码清晰表达意图：是立即处理、记录日志，还是向上层传播。? 运算符不是隐藏错误，而是显式声明“此处若失败，我选择不处理，交给调用者”。