可恢复 vs 不可恢复错误 ​

核心概念 ​

Rust 将错误分为两大类:可恢复错误(Recoverable Errors)和不可恢复错误(Unrecoverable Errors)。可恢复错误是程序运行中预期可能发生的问题,比如文件不存在、网络超时、用户输入无效等,用 Result<T, E> 表示,调用者可以选择重试、回退或向上层传递。不可恢复错误是程序中的 bug,比如数组越界、违反不变条件等,用 panic! 处理,程序应该立即停止。这两种错误的处理方式完全不同,选择正确的方式是写出可靠 Rust 程序的关键。

rust
use std::fs;
use std::num::ParseIntError;

// 可恢复错误:用 Result 返回
fn read_config(path: &str) -> Result<String, std::io::Error> {
    fs::read_to_string(path)  // 文件可能不存在,这是预期中的
}

// 可恢复错误:用户输入可能无效
fn parse_age(input: &str) -> Result<u32, ParseIntError> {
    input.parse::<u32>()
}

// 不可恢复错误:违反了不变条件
fn get_element(data: &[i32], index: usize) -> i32 {
    assert!(index < data.len(), "索引 {} 越界,长度 {}", index, data.len());
    data[index]
}

fn main() {
    // 可恢复错误:优雅地处理
    match read_config("config.toml") {
        Ok(content) => println!("配置: {}", content),
        Err(e) => println!("读取配置失败: {},使用默认配置", e),
    }

    match parse_age("25") {
        Ok(age) => println!("年龄: {}", age),
        Err(e) => println!("输入无效: {}", e),
    }

    // 不可恢复错误:程序 bug,直接 panic
    let data = vec![1, 2, 3];
    println!("元素: {}", get_element(&data, 0));
    // get_element(&data, 10);  // 这是 bug,会 panic
}

判断标准 ​

判断依据可恢复(Result)不可恢复(panic)
是否预期预期可能发生不应该发生
谁的错外部因素(用户、环境)程序员的 bug
能否继续可以用替代方案继续无法安全继续
调用者能处理吗能不能
示例文件不存在、网络断开数组越界、逻辑错误
rust
use std::collections::HashMap;

// 预期会发生的错误 → Result
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("除数为零"))  // 调用者可以处理
    } else {
        Ok(a / b)
    }
}

// 不应该发生的错误 → panic
fn internal_divide(a: f64, b: f64) -> f64 {
    // 如果调用方已经验证 b != 0,到这里 b 仍然是 0 就是 bug
    assert!(b != 0.0, "内部错误:除数为零(调用方应先验证)");
    a / b
}

// 查找操作:找不到是正常情况 → Option/Result
fn find_user(users: &HashMap<u32, String>, id: u32) -> Option<&String> {
    users.get(&id)  // 找不到是预期的
}

// 配置加载:缺少必要配置 → panic(程序无法运行)
fn load_required_config(key: &str) -> String {
    // 必要配置缺失意味着部署有问题,无法恢复
    std::env::var(key)
        .unwrap_or_else(|_| panic!("必要的环境变量 {} 未设置", key))
}

fn main() {
    // 可恢复:提供回退方案
    let result = divide(10.0, 0.0);
    let value = match result {
        Ok(v) => v,
        Err(e) => {
            println!("计算失败: {},使用默认值 0", e);
            0.0
        }
    };
    println!("结果: {}", value);

    // 可恢复:查找可能失败
    let mut users = HashMap::new();
    users.insert(1, String::from("张三"));

    match find_user(&users, 2) {
        Some(name) => println!("用户: {}", name),
        None => println!("用户不存在"),
    }
}

常见错误场景分类 ​

应该用 Result 的场景 ​

rust
use std::fs;
use std::io;
use std::net::TcpStream;

// 文件操作:文件可能不存在、权限不足等
fn read_file(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)
}

// 解析操作:输入格式可能不对
fn parse_config_line(line: &str) -> Result<(String, String), String> {
    let parts: Vec<&str> = line.splitn(2, '=').collect();
    if parts.len() != 2 {
        return Err(format!("无效的配置行: '{}'", line));
    }
    Ok((parts[0].trim().to_string(), parts[1].trim().to_string()))
}

// 网络操作:连接可能失败
fn connect_to_server(addr: &str) -> Result<TcpStream, io::Error> {
    TcpStream::connect(addr)
}

// 数据验证:输入可能无效
fn validate_email(email: &str) -> Result<String, String> {
    if !email.contains('@') {
        return Err(format!("'{}' 不是有效的邮箱地址", email));
    }
    if email.len() < 5 {
        return Err(String::from("邮箱地址太短"));
    }
    Ok(email.to_string())
}

fn main() {
    // 文件读取:提供回退
    let config = read_file("app.conf")
        .unwrap_or_else(|_| String::from("# 默认配置\nport=8080"));
    println!("配置内容:\n{}", config);

    // 解析:跳过无效行
    let lines = vec!["host = localhost", "port = 8080", "无效行", "debug = true"];
    for line in &lines {
        match parse_config_line(line) {
            Ok((key, value)) => println!("  {} = {}", key, value),
            Err(e) => println!("  跳过: {}", e),
        }
    }

    // 验证:告知用户错误
    match validate_email("user@example.com") {
        Ok(email) => println!("有效邮箱: {}", email),
        Err(e) => println!("验证失败: {}", e),
    }
}

应该用 panic 的场景 ​

rust
// 初始化失败:缺少关键资源,程序无法运行
fn init_database() -> String {
    // 数据库地址是运行的前提条件
    std::env::var("DATABASE_URL")
        .expect("环境变量 DATABASE_URL 必须设置")
}

// 不变条件被违反:说明代码有 bug
fn calculate_average(numbers: &[f64]) -> f64 {
    // 调用方应该保证列表非空
    assert!(!numbers.is_empty(), "列表不能为空(这是调用方的 bug)");
    let sum: f64 = numbers.iter().sum();
    sum / numbers.len() as f64
}

// 逻辑上不可能的分支
fn day_type(day: u8) -> &'static str {
    match day {
        1..=5 => "工作日",
        6 | 7 => "周末",
        _ => unreachable!("天数应该在 1-7 之间,这是调用方的 bug"),
    }
}

// 类型状态不一致:表示程序逻辑错误
#[derive(Debug)]
enum State { Ready, Running, Done }

struct Machine {
    state: State,
}

impl Machine {
    fn new() -> Self {
        Machine { state: State::Ready }
    }

    fn start(&mut self) {
        match self.state {
            State::Ready => self.state = State::Running,
            _ => panic!("只能从 Ready 状态启动,当前: {:?}", self.state),
        }
    }

    fn finish(&mut self) {
        match self.state {
            State::Running => self.state = State::Done,
            _ => panic!("只能从 Running 状态完成,当前: {:?}", self.state),
        }
    }
}

fn main() {
    let mut m = Machine::new();
    m.start();
    m.finish();
    println!("机器状态: {:?}", m.state);

    // m.start();  // panic:从 Done 状态启动
}

灰色地带:如何选择 ​

有些场景两种方式都说得通,需要根据具体情况判断。

rust
// 灰色地带1:构造器验证
// 方案A:panic(认为调用方应该保证参数合法)
struct PortA(u16);
impl PortA {
    fn new(port: u16) -> Self {
        assert!(port > 0, "端口号必须大于 0");
        PortA(port)
    }
}

// 方案B:Result(认为端口号可能来自用户输入)
struct PortB(u16);
impl PortB {
    fn new(port: u16) -> Result<Self, String> {
        if port == 0 {
            Err(String::from("端口号不能为 0"))
        } else {
            Ok(PortB(port))
        }
    }
}

// 灰色地带2:数组访问
fn get_safe(v: &[i32], i: usize) -> Option<i32> {
    // Option:调用者可能不确定索引是否有效
    v.get(i).copied()
}

fn get_unsafe(v: &[i32], i: usize) -> i32 {
    // panic(通过 []):调用者保证索引合法
    v[i]
}

// 决策原则:
// - 数据来自外部(用户、文件、网络) → Result/Option
// - 数据来自程序内部,已经验证过 → panic
// - 库的公开 API → Result/Option(对使用者友好)
// - 库的内部逻辑 → assert/panic(快速发现 bug)

fn main() {
    // 方案A:简洁但调用者需自己验证
    let _port = PortA::new(8080);
    // PortA::new(0);  // panic

    // 方案B:调用者被迫处理错误
    match PortB::new(8080) {
        Ok(p) => println!("端口: {}", p.0),
        Err(e) => println!("错误: {}", e),
    }

    let v = vec![1, 2, 3];
    println!("安全获取: {:?}", get_safe(&v, 5));  // None
    println!("直接获取: {}", get_unsafe(&v, 0));   // 1
}

基本示例 ​

用两种错误处理方式实现一个用户注册系统:

rust
use std::collections::HashMap;

#[derive(Debug, Clone)]
struct User {
    username: String,
    email: String,
    age: u32,
}

// 可恢复错误:验证失败
#[derive(Debug)]
enum ValidationError {
    UsernameTooShort(usize),
    UsernameTooLong(usize),
    InvalidEmail(String),
    InvalidAge(u32),
    UserExists(String),
}

impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ValidationError::UsernameTooShort(len) => {
                write!(f, "用户名太短({}字符,最少3字符)", len)
            }
            ValidationError::UsernameTooLong(len) => {
                write!(f, "用户名太长({}字符,最多20字符)", len)
            }
            ValidationError::InvalidEmail(email) => {
                write!(f, "邮箱地址无效: {}", email)
            }
            ValidationError::InvalidAge(age) => {
                write!(f, "年龄无效: {}(应在1-150之间)", age)
            }
            ValidationError::UserExists(name) => {
                write!(f, "用户名 '{}' 已存在", name)
            }
        }
    }
}

struct UserRegistry {
    users: HashMap<String, User>,
    max_capacity: usize,
}

impl UserRegistry {
    fn new(max_capacity: usize) -> Self {
        // 不可恢复:容量为 0 是配置错误
        assert!(max_capacity > 0, "注册表容量必须大于 0");
        UserRegistry {
            users: HashMap::new(),
            max_capacity,
        }
    }

    // 可恢复错误:注册可能因各种原因失败
    fn register(&mut self, username: &str, email: &str, age: u32)
        -> Result<&User, ValidationError>
    {
        // 验证用户名
        if username.len() < 3 {
            return Err(ValidationError::UsernameTooShort(username.len()));
        }
        if username.len() > 20 {
            return Err(ValidationError::UsernameTooLong(username.len()));
        }

        // 验证邮箱
        if !email.contains('@') || email.len() < 5 {
            return Err(ValidationError::InvalidEmail(email.to_string()));
        }

        // 验证年龄
        if age == 0 || age > 150 {
            return Err(ValidationError::InvalidAge(age));
        }

        // 检查重复
        if self.users.contains_key(username) {
            return Err(ValidationError::UserExists(username.to_string()));
        }

        // 不可恢复:超过容量是系统 bug(应该在业务层控制)
        assert!(
            self.users.len() < self.max_capacity,
            "注册表已满(容量: {}),业务层应在注册前检查",
            self.max_capacity
        );

        let user = User {
            username: username.to_string(),
            email: email.to_string(),
            age,
        };
        self.users.insert(username.to_string(), user);
        Ok(self.users.get(username).unwrap())
    }

    fn count(&self) -> usize {
        self.users.len()
    }

    fn is_full(&self) -> bool {
        self.users.len() >= self.max_capacity
    }

    // 不可恢复:内部方法,调用方保证用户存在
    fn get_internal(&self, username: &str) -> &User {
        self.users.get(username)
            .unwrap_or_else(|| panic!("内部错误:用户 '{}' 应该存在", username))
    }

    // 可恢复:公开 API,用户可能不存在
    fn find(&self, username: &str) -> Option<&User> {
        self.users.get(username)
    }
}

fn main() {
    let mut registry = UserRegistry::new(100);

    // 尝试注册(可恢复错误)
    let registrations = vec![
        ("张三", "zhangsan@example.com", 25u32),
        ("ab", "short@a.com", 30),              // 用户名太短
        ("李四", "invalid_email", 28),           // 邮箱无效
        ("王五", "wangwu@test.com", 0),          // 年龄无效
        ("张三", "zhangsan2@test.com", 26),      // 用户名重复
        ("赵六", "zhaoliu@test.com", 35),        // 成功
    ];

    println!("=== 用户注册 ===");
    for (name, email, age) in &registrations {
        match registry.register(name, email, *age) {
            Ok(user) => println!("  注册成功: {:?}", user),
            Err(e) => println!("  注册失败: {}", e),
        }
    }

    println!("\n注册用户数: {}", registry.count());

    // 查找用户(可恢复)
    println!("\n=== 查找用户 ===");
    for name in &["张三", "不存在的用户", "赵六"] {
        match registry.find(name) {
            Some(user) => println!("  找到: {} ({})", user.username, user.email),
            None => println!("  未找到: {}", name),
        }
    }
}

常见问题 ​

问题一:库应该用 panic 还是 Result?

公开 API 应该尽量使用 Result,让调用者决定如何处理错误。内部断言和不变条件检查可以用 panic。总的原则是:不要替用户做"程序应该崩溃"的决定。

问题二:unwrap 和 expect 算不算 panic?

算。unwrap() 和 expect() 在 None 或 Err 时会调用 panic!。生产代码中应该谨慎使用,expect 比 unwrap 好一点因为可以附带错误说明。

问题三:什么时候用 Option,什么时候用 Result?

Option<T> 表示"有或没有",不关心为什么没有。Result<T, E> 表示"成功或失败",失败时需要知道原因。如果调用者需要知道失败原因,用 Result;只需要知道有没有值,用 Option。

类型含义失败信息典型场景
Option<T>有值/无值无查找、可选字段
Result<T, E>成功/失败有(错误类型 E)IO、解析、验证

问题四:程序启动时用 panic 还是 Result?

启动阶段(初始化配置、连接数据库等)如果失败意味着程序无法运行,用 expect 或 panic 是合理的。一旦进入正常运行阶段,应该用 Result 处理错误。

适用场景 ​

  • Result:文件操作、网络请求、用户输入、数据解析、库 API
  • panic:不变条件检查、初始化失败、程序 bug、不可达分支

注意事项 ​

  • 可恢复错误用 Result/Option,不可恢复错误用 panic!
  • 数据来自外部(用户、文件、网络)→ Result
  • 数据来自内部、已验证 → assert/panic
  • 库的公开 API 优先用 Result
  • unwrap 和 expect 本质是 panic,慎用
  • 初始化阶段 panic 是可以接受的
  • 不要用 catch_unwind 模拟异常处理

总结 ​

Rust 把错误分为可恢复(Result<T, E>/Option<T>)和不可恢复(panic!)两类。可恢复错误是预期可能发生的问题,调用者可以选择重试、回退或传播;不可恢复错误表示程序有 bug,应该立即停止。判断标准是:错误是否预期会发生、调用者能否合理处理、继续运行是否安全。外部数据导致的失败用 Result,内部逻辑错误用 panic。库的公开 API 应优先使用 Result,让调用者决定如何处理。正确区分这两种错误是写出可靠 Rust 程序的关键。