Rust 错误处理：Result 与 Option 类型

Rust 通过 Result 和 Option 类型强制你在编译期就考虑错误和缺失值的情况，避免运行时崩溃。这两种类型是 Rust 安全性和可靠性的重要基石。

理解 Option：表示“可能没有值”

当你有一个值，但它可能不存在（比如从哈希表中查找一个键），Rust 不允许你直接使用空指针或 null。相反，你必须使用 Option<T>。

Option<T> 是一个枚举，只有两个变体：

• Some(value)：包含一个类型为 T 的值。
• None：表示没有值。

创建 Option 值：

let some_number = Some(5);
let no_number: Option<i32> = None;

访问 Option 中的值：
不要直接假设值存在。Rust 要求你显式处理两种情况。

1. 使用 match 进行模式匹配：

   let maybe_name = Some("Alice");
   match maybe_name {
       Some(name) => println!("Hello, {}!", name),
       None => println!("Name is missing."),
   }

2. 使用 unwrap_or 提供默认值：

   let config_value = get_config("timeout"); // 返回 Option<i32>
   let timeout = config_value.unwrap_or(30); // 如果是 None，就用 30

3. 使用 if let 简化单一分支处理：

   if let Some(age) = user_age {
       println!("User is {} years old.", age);
   }

不要滥用 unwrap()：unwrap() 在值为 Some 时返回内部值，但在 None 时会 panic（程序崩溃）。仅在你 100% 确定值存在时使用，例如测试代码。

理解 Result：表示“可能失败的操作”

当你调用一个可能失败的函数（如读取文件、网络请求），Rust 要求你使用 Result<T, E>。

Result<T, E> 也是一个枚举，有两个变体：

• Ok(value)：操作成功，包含类型为 T 的结果。
• Err(error)：操作失败，包含类型为 E 的错误信息。

创建 Result 值：

use std::fs::File;

let file_result: Result<File, std::io::Error> = File::open("data.txt");

处理 Result：

1. 使用 match 处理成功与失败：

   match File::open("config.toml") {
       Ok(file) => {
           println!("File opened successfully.");
           // 使用 file
       }
       Err(error) => {
           println!("Failed to open file: {}", error);
       }
   }

2. 使用 unwrap_or_else 提供错误处理逻辑：

   let file = File::open("app.log")
       .unwrap_or_else(|error| {
           eprintln!("Cannot open log file: {}", error);
           std::process::exit(1);
       });

3. 使用 ? 操作符向上传播错误（推荐用于函数）：

   use std::fs::File;
   use std::io;
   
   fn read_first_byte(filename: &str) -> io::Result<u8> {
       let mut file = File::open(filename)?; // 如果失败，立即返回 Err
       let mut buffer = [0; 1];
       file.read_exact(&mut buffer)?;
       Ok(buffer[0])
   }

   注意：使用 ? 的函数返回类型必须是 Result 或 Option。

组合 Option 与 Result

实际开发中，你经常需要链式处理多个可能失败或缺失的操作。

使用 and_then 链接 Option：

fn parse_positive(input: &str) -> Option<i32> {
    input.parse::<i32>().ok().and_then(|n| {
        if n > 0 { Some(n) } else { None }
    })
}

使用 map 处理成功值，不影响错误路径：

let filename = Some("data.txt");
let file_size: Option<u64> = filename
    .map(|name| std::fs::metadata(name))
    .and_then(|meta_result| meta_result.ok())
    .map(|meta| meta.len());

在 Result 上使用 map 和 and_then：

fn double_file_size(path: &str) -> Result<u64, std::io::Error> {
    std::fs::metadata(path)
        .map(|m| m.len() * 2) // 成功时对值做变换
}

自定义错误类型（进阶）

标准库的错误类型（如 std::io::Error）适合通用场景，但复杂项目应定义自己的错误类型。

1. 定义错误枚举：

   #[derive(Debug)]
   enum AppError {
       IoError(std::io::Error),
       ParseError(String),
       NotFound,
   }

2. 实现 From trait 以支持 ? 操作符自动转换：

   impl From<std::io::Error> for AppError {
       fn from(error: std::io::Error) -> Self {
           AppError::IoError(error)
       }
   }
   
   fn load_config() -> Result<String, AppError> {
       let content = std::fs::read_to_string("config.yaml")?; // 自动转为 AppError
       Ok(content)
   }

3. 使用 anyhow 或 thiserror 库简化错误处理（生产推荐）：

   • anyhow::Result：适合应用层，提供灵活的错误上下文。
   • thiserror::Error：适合库开发，零开销自定义错误。

常见陷阱与最佳实践

1. 避免嵌套 match：过多嵌套会降低可读性。优先使用 ?、map、and_then 组合。
2. 不要忽略错误：即使暂时不想处理，也应显式记录：

   let _ = File::create("temp.log"); // 明确表示忽略结果

3. 区分 panic 和错误：
   • panic：表示程序 bug（如数组越界），不可恢复。
   • Result/Option：表示预期中的失败（如文件不存在），应被处理。
4. 在 main 函数中处理顶层错误：

   fn main() -> Result<(), Box<dyn std::error::Error>> {
       let data = std::fs::read_to_string("input.txt")?;
       println!("Read {} bytes", data.len());
       Ok(())
   }

尽早处理 Option/Result：不要把 Option<Option<T>> 或 Result<Result<T, E>, E> 传给下一层。使用 flatten() 或提前解包。

let nested: Option<Option<i32>> = Some(Some(42));
let flat: Option<i32> = nested.flatten(); // 得到 Some(42)