第六章：错误处理——优雅地面对失败

本章导读：程序难免会遇到意外情况：文件不存在、网络超时、数据格式错误……如何优雅地处理这些情况，决定了代码的健壮性。Rust 摒弃了异常机制，转而使用 Option 和 Result 类型让错误处理成为类型系统的一部分。本章将揭示 Rust 如何让错误"显式化"，以及如何用 ? 操作符简化错误传播。

🤔 6.1 为什么Rust不用异常？

在深入技术细节之前，让我们理解 Rust 的设计哲学。

⚠️ 6.1.1 异常的问题

传统的异常机制（如 Java、Python、C++）有几个问题：

隐式控制流：任何函数都可能抛出异常，但函数签名不会告诉你。阅读代码时，你必须时刻提防潜在的异常。

容易被忽略：没有什么强制你处理异常——忘记写 catch 也不会编译报错，直到运行时程序崩溃。

性能开销：异常处理需要运行时栈展开机制，即使在正常路径上也有开销。

🎯 6.1.2 Rust的方案

Rust 选择让错误成为类型系统的一部分：

Option<T> 表示可能没有值
Result<T, E> 表示可能失败的操作

这带来的好处：

显式可见：函数签名清楚表明可能失败，编译器强制你处理。

零运行时开销：正常路径上没有异常检查的开销。

组合性强：可以链式调用、模式匹配、与迭代器配合。

第一性原理思考：错误处理的本质是什么？是"如何让程序在意外情况下仍然正确"。Rust 的方式是把"意外情况"编码到类型中，让编译器帮你确保所有情况都被处理。

🔘 6.2 `Option<T>`：处理缺失值

Option 表示一个值可能存在，也可能不存在：

enum Option<T> {
    Some(T),
    None,
}

📖 6.2.1 基本用法

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some(String::from("张三"))
    } else if id == 2 {
        Some(String::from("李四"))
    } else {
        None
    }
}

fn main() {
    let user = find_user(1);
    
    // 方式一：match
    match user {
        Some(name) => println!("找到用户: {}", name),
        None => println!("用户不存在"),
    }
}

🔧 6.2.2 `Option` 的常用方法

let some = Some(42);
let none: Option<i32> = None;

// unwrap：获取值，None 会 panic
// println!("{}", none.unwrap());  // 危险！

// unwrap_or：提供默认值
println!("{}", none.unwrap_or(0));  // 0

// unwrap_or_else：使用闭包计算默认值
println!("{}", none.unwrap_or_else(|| {
    println!("计算默认值...");
    100
}));

// unwrap_or_default：使用类型的默认值
println!("{}", none.unwrap_or_default());  // 0

// expect：自定义 panic 消息
// println!("{}", none.expect("应该有值"));  // panic: 应该有值

// map：转换 Some 中的值
let doubled = some.map(|x| x * 2);
println!("{:?}", doubled);  // Some(84)

// and_then：链式操作（类似 flatMap）
let result = some.and_then(|x| {
    if x > 40 {
        Some(x)
    } else {
        None
    }
});

// or：提供备选 Option
let backup = Some(100);
let value = none.or(backup);
println!("{:?}", value);  // Some(100)

// ok_or：转换为 Result
let result: Result<i32, &str> = none.ok_or("没有值");
println!("{:?}", result);  // Err("没有值")

🔗 6.2.3 组合多个 Option

fn add_two_options(a: Option<i32>, b: Option<i32>) -> Option<i32> {
    // 使用 and_then 链式调用
    a.and_then(|x| b.map(|y| x + y))
}

// 使用 ? 操作符更简洁
fn add_two_options_simple(a: Option<i32>, b: Option<i32>) -> Option<i32> {
    Some(a? + b?)
}

🧪 6.2.4 实战示例：安全除法

fn divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    let result = divide(10, 2);
    match result {
        Some(q) => println!("10 / 2 = {}", q),
        None => println!("除零错误"),
    }
    
    // 链式操作
    let a = divide(10, 2);
    let b = divide(8, 4);
    let sum = a.and_then(|x| b.map(|y| x + y));
    println!("(10/2) + (8/4) = {:?}", sum);  // Some(7)
}

⚠️ 6.3 `Result<T, E>`：处理错误

Result 表示一个操作可能成功，也可能失败：

enum Result<T, E> {
    Ok(T),   // 成功，包含值
    Err(E),  // 失败，包含错误信息
}

📖 6.3.1 基本用法

use std::fs::File;
use std::io::Error;

fn open_file(path: &str) -> Result<File, Error> {
    File::open(path)
}

fn main() {
    match open_file("data.txt") {
        Ok(file) => println!("文件打开成功"),
        Err(e) => println!("打开失败: {}", e),
    }
}

🔧 6.3.2 `Result` 的常用方法

let ok: Result<i32, &str> = Ok(42);
let err: Result<i32, &str> = Err("出错了");

// unwrap 和 expect（生产代码慎用）
// println!("{}", err.unwrap());  // panic!
// println!("{}", err.expect("应该成功"));  // panic!

// unwrap_or, unwrap_or_else
println!("{}", err.unwrap_or(0));  // 0

// map, map_err
let mapped = ok.map(|x| x * 2);  // Ok(84)
let err_mapped = err.map_err(|e| format!("错误: {}", e));

// and_then
let chained = ok.and_then(|x| {
    if x > 40 {
        Ok(x)
    } else {
        Err("值太小")
    }
});

// ok, err（转换为 Option）
let ok_option = ok.ok();  // Some(42)
let err_option = err.err();  // Some("出错了")

// is_ok, is_err
if ok.is_ok() {
    println!("成功了");
}

🚀 6.3.3 `?` 操作符：优雅的错误传播

? 操作符是 Rust 错误处理的精髓：

use std::fs::File;
use std::io::{self, Read};

// 不使用 ? 的版本
fn read_file_old(path: &str) -> Result<String, io::Error> {
    let file = match File::open(path) {
        Ok(f) => f,
        Err(e) => return Err(e),
    };
    
    let mut contents = String::new();
    match file.read_to_string(&mut contents) {
        Ok(_) => {}
        Err(e) => return Err(e),
    }
    
    Ok(contents)
}

// 使用 ? 的版本
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

// 更简洁的写法
fn read_file_concise(path: &str) -> Result<String, io::Error> {
    std::fs::read_to_string(path)
}

? 操作符的工作原理：

如果是 Ok(v)，返回 v
如果是 Err(e)，立即返回 Err(From::from(e))

🔄 6.3.4 错误类型转换

? 操作符会自动进行错误类型转换（通过 From trait）：

use std::fs::File;
use std::io;

// 自定义错误类型
#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Parse(std::num::ParseIntError),
}

// 实现 From trait，支持自动转换
impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self {
        AppError::Io(e)
    }
}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::Parse(e)
    }
}

fn read_and_parse(path: &str) -> Result<i32, AppError> {
    let content = std::fs::read_to_string(path)?;  // io::Error -> AppError
    let number: i32 = content.trim().parse()?;     // ParseIntError -> AppError
    Ok(number)
}

🏗️ 6.4 定义自己的错误类型

对于库和应用，定义清晰的错误类型是最佳实践。

📦 6.4.1 基本自定义错误

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

#[derive(Debug)]
pub struct ParseConfigError {
    pub message: String,
    pub line: usize,
}

impl fmt::Display for ParseConfigError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "配置解析错误 (第 {} 行): {}", self.line, self.message)
    }
}

impl Error for ParseConfigError {}

fn parse_config(content: &str) -> Result<Config, ParseConfigError> {
    // ...
    Err(ParseConfigError {
        message: String::from("缺少必要的字段"),
        line: 10,
    })
}

🛠️ 6.4.2 使用 `thiserror` 简化

thiserror 是一个用于库的派生宏，可以大大简化错误类型定义：

use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataStoreError {
    #[error("数据删除失败")]
    Delete(#[source] std::io::Error),
    
    #[error("连接超时")]
    Timeout,
    
    #[error("无效的 ID: {0}")]
    InvalidId(String),
    
    #[error("未知错误")]
    Unknown,
}

📦 6.4.3 使用 `anyhow` 简化应用

anyhow 适合应用程序，提供灵活的错误处理：

use anyhow::{Context, Result};

fn read_config(path: &str) -> Result<Config> {
    let content = std::fs::read_to_string(path)
        .context(format!("无法读取配置文件: {}", path))?;
    
    let config: Config = toml::from_str(&content)
        .context("配置文件格式错误")?;
    
    Ok(config)
}

fn main() -> Result<()> {
    let config = read_config("config.toml")?;
    println!("配置加载成功");
    Ok(())
}

thiserror vs anyhow：thiserror 用于库，生成清晰的错误类型，让使用者能够精确处理各种错误。anyhow 用于应用，提供便捷的错误传播和上下文信息。原则：库用 thiserror，应用用 anyhow。

🎯 6.5 错误处理策略

🛡️ 6.5.1 什么时候 panic？

虽然 Rust 鼓励使用 Result，但有时 panic! 是合适的：

// 示例代码、原型：简单起见可以使用 unwrap
let x = some_value.unwrap();

// 程序不变量被违反：比继续运行更严重的问题
fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("除零错误：这是程序逻辑 bug");
    }
    a / b
}

// 初始化阶段：如果失败，程序无法继续
fn main() {
    let config = load_config().expect("必须提供配置文件");
    // ...
}

原则：

如果错误是可预期的、应该被调用者处理的，使用 Result
如果错误表示程序 bug 或不可恢复的系统性问题，使用 panic

🔄 6.5.2 将 panic 转换为 Result

// 使用 catch_unwind 捕获 panic
use std::panic;

fn risky_operation() -> Result<String, String> {
    let result = panic::catch_unwind(|| {
        // 可能 panic 的代码
        String::from("成功")
    });
    
    match result {
        Ok(value) => Ok(value),
        Err(_) => Err(String::from("操作失败")),
    }
}

🎭 6.5.3 自定义 Panic 处理

use std::panic;

fn main() {
    panic::set_hook(Box::new(|info| {
        eprintln!("程序崩溃了！");
        eprintln!("位置: {:?}", info.location());
        if let Some(s) = info.payload().downcast_ref::<&str>() {
            eprintln!("消息: {}", s);
        }
    }));
    
    panic!("哦不！");
}

🧪 6.6 实战：构建健壮的配置加载器

use std::collections::HashMap;
use std::fs;
use std::path::Path;
use thiserror::Error;

#[derive(Debug, Clone)]
pub struct Config {
    pub database_url: String,
    pub port: u16,
    pub debug: bool,
    pub features: Vec<String>,
}

#[derive(Error, Debug)]
pub enum ConfigError {
    #[error("文件读取失败: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("配置格式错误: {0}")]
    Format(String),
    
    #[error("缺少必要字段: {0}")]
    MissingField(String),
    
    #[error("字段类型错误: {0}")]
    TypeError(String),
}

impl Config {
    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, ConfigError> {
        let content = fs::read_to_string(path)?;
        Self::from_str(&content)
    }
    
    pub fn from_str(content: &str) -> Result<Self, ConfigError> {
        let lines: Vec<&str> = content.lines().collect();
        let mut map = HashMap::new();
        
        for (line_num, line) in lines.iter().enumerate() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            
            let parts: Vec<&str> = line.splitn(2, '=').collect();
            if parts.len() != 2 {
                return Err(ConfigError::Format(format!(
                    "第 {} 行格式错误", line_num + 1
                )));
            }
            
            map.insert(parts[0].trim().to_string(), parts[1].trim().to_string());
        }
        
        let database_url = map.get("database_url")
            .ok_or_else(|| ConfigError::MissingField("database_url".into()))?
            .clone();
        
        let port: u16 = map.get("port")
            .ok_or_else(|| ConfigError::MissingField("port".into()))?
            .parse()
            .map_err(|_| ConfigError::TypeError("port 必须是数字".into()))?;
        
        let debug = map.get("debug")
            .map(|v| v == "true")
            .unwrap_or(false);
        
        let features = map.get("features")
            .map(|v| v.split(',').map(|s| s.trim().to_string()).collect())
            .unwrap_or_default();
        
        Ok(Config {
            database_url,
            port,
            debug,
            features,
        })
    }
}

fn main() {
    let config_content = r#"
        database_url = postgres://localhost/mydb
        port = 8080
        debug = true
        features = auth, logging
    "#;
    
    match Config::from_str(config_content) {
        Ok(config) => {
            println!("配置加载成功:");
            println!("  数据库: {}", config.database_url);
            println!("  端口: {}", config.port);
            println!("  调试: {}", config.debug);
            println!("  功能: {:?}", config.features);
        }
        Err(e) => {
            eprintln!("配置错误: {}", e);
            std::process::exit(1);
        }
    }
}

📝 本章小结

本章我们学习了 Rust 的错误处理机制：

<code>Option<T></code> 表示可能缺失的值，使用 Some 和 None
<code>Result<T, E></code> 表示可能失败的操作，使用 Ok 和 Err
<code>?</code> 操作符 简化错误传播，自动转换错误类型
<code>thiserror</code> 用于库的错误类型定义
<code>anyhow</code> 用于应用的灵活错误处理

关键要点：

让错误成为类型系统的一部分，编译器帮你确保处理
优先使用 Result 而非 panic，除非遇到不可恢复的错误
使用 ? 操作符让错误处理代码简洁易读
为库定义清晰的错误类型，让调用者能精确处理

在下一章，我们将学习 Rust 的模块系统和包管理——如何组织大型代码库。

动手实验：

重写之前的 divide 函数，返回 Result<i32, String> 而不是 panic。

使用 ? 操作符重写以下代码：

``rust fn process(s: String) -> Result { match s.parse::() { Ok(n) => Ok(n * 2), Err(e) => Err(e), } }``

使用 thiserror 定义一个错误类型，包含"用户不存在"和"密码错误"两种变体。

第六章：错误处理——优雅地面对失败

第六章：错误处理——优雅地面对失败

🤔 6.1 为什么Rust不用异常？

⚠️ 6.1.1 异常的问题

🎯 6.1.2 Rust的方案

🔘 6.2 Option<T>：处理缺失值

📖 6.2.1 基本用法

🔧 6.2.2 Option 的常用方法

🔗 6.2.3 组合多个 Option

🧪 6.2.4 实战示例：安全除法

⚠️ 6.3 Result<T, E>：处理错误

📖 6.3.1 基本用法

🔧 6.3.2 Result 的常用方法

🚀 6.3.3 ? 操作符：优雅的错误传播

🔄 6.3.4 错误类型转换

🏗️ 6.4 定义自己的错误类型

📦 6.4.1 基本自定义错误

🛠️ 6.4.2 使用 thiserror 简化

📦 6.4.3 使用 anyhow 简化应用

🎯 6.5 错误处理策略

🛡️ 6.5.1 什么时候 panic？

🔄 6.5.2 将 panic 转换为 Result

🎭 6.5.3 自定义 Panic 处理

🧪 6.6 实战：构建健壮的配置加载器

📝 本章小结

🔘 6.2 `Option<T>`：处理缺失值

🔧 6.2.2 `Option` 的常用方法

⚠️ 6.3 `Result<T, E>`：处理错误

🔧 6.3.2 `Result` 的常用方法

🚀 6.3.3 `?` 操作符：优雅的错误传播

🛠️ 6.4.2 使用 `thiserror` 简化

📦 6.4.3 使用 `anyhow` 简化应用