🦀 Rust 错误处理机制教程#

目录#

错误分类
panic! 宏（不可恢复错误）
Option 类型
Result 类型
错误传播（? 运算符）
自定义错误类型
错误链和上下文
综合示例
总结

1️⃣ 错误分类#

Rust 将错误分为两类：

不可恢复错误（Unrecoverable）
- 程序无法继续运行
- 使用 panic! 触发
- 例如数组越界、unwrap None
可恢复错误（Recoverable）
- 可以通过程序逻辑处理
- 使用 Result<T, E> 表示
- 例如文件不存在、网络请求失败

2️⃣ panic! 宏（不可恢复错误）#

1
fn main() {
2
    let v = vec![1, 2, 3];
3
    // println!("{}", v[10]); // ❌ panic: 索引越界
4
    panic!("程序遇到致命错误");
5
}

会立即中止程序
可在测试中用作断言

1
fn divide(a: i32, b: i32) -> i32 {
2
    if b == 0 { panic!("除数不能为0"); }
3
    a / b
4
}

3️⃣ Option 类型#

用于 值可能存在或不存在：

1
let value: Option<i32> = Some(10);
2
let no_value: Option<i32> = None;
3

4
// 安全访问
5
if let Some(v) = value {
6
    println!("value = {}", v);
7
}
8

9
// 默认值
10
println!("no_value = {}", no_value.unwrap_or(0));

常用方法：

is_some() / is_none()
unwrap()（可能 panic）
unwrap_or(default)
map() / and_then()

4️⃣ Result 类型#

用于 可恢复错误：

1
fn divide(a: i32, b: i32) -> Result<i32, String> {
2
    if b == 0 { Err("除数不能为0".to_string()) } else { Ok(a / b) }
3
}
4

5
fn main() {
6
    match divide(10, 2) {
7
        Ok(v) => println!("结果 = {}", v),
8
        Err(e) => println!("错误 = {}", e),
9
    }
10
}

常用方法：

unwrap() / unwrap_or() / expect()
map() / and_then() / or_else()
is_ok() / is_err()

5️⃣ 错误传播（? 运算符）#

快速将错误返回给调用者：

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

4
fn read_file(path: &str) -> io::Result<String> {
5
    let mut file = File::open(path)?;      // 出错直接返回 Err
6
    let mut contents = String::new();
7
    file.read_to_string(&mut contents)?;
8
    Ok(contents)
9
}
10

11
fn main() {
12
    match read_file("test.txt") {
13
        Ok(text) => println!("{}", text),
14
        Err(e) => println!("读取失败: {}", e),
15
    }
16
}

? 只能在返回 Result 或 Option 的函数中使用。

6️⃣ 自定义错误类型#

使用 enum 定义错误类型
实现 std::fmt::Display 和 std::error::Error

1
use std::fmt;
2

3
#[derive(Debug)]
4
enum MyError {
5
    InvalidInput,
6
    DivideByZero,
7
}
8

9
impl fmt::Display for MyError {
10
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11
        match self {
12
            MyError::InvalidInput => write!(f, "输入无效"),
13
            MyError::DivideByZero => write!(f, "除数为0"),
14
        }
15
    }
16
}
17

18
impl std::error::Error for MyError {}

函数返回自定义错误：

1
fn divide(a: i32, b: i32) -> Result<i32, MyError> {
2
    if b == 0 { return Err(MyError::DivideByZero); }
3
    Ok(a / b)
4
}

7️⃣ 错误链和上下文#

使用 anyhow 或 thiserror crate
可保存错误来源和上下文，方便调试

1
use anyhow::{Result, Context};
2
use std::fs::File;
3

4
fn read_file(path: &str) -> Result<String> {
5
    let mut file = File::open(path).context("打开文件失败")?;
6
    let mut contents = String::new();
7
    file.read_to_string(&mut contents).context("读取文件失败")?;
8
    Ok(contents)
9
}

错误链可以显示完整调用路径和原因。

8️⃣ 综合示例#

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

4
fn read_file(path: &str) -> io::Result<String> {
5
    let mut file = File::open(path)?;
6
    let mut contents = String::new();
7
    file.read_to_string(&mut contents)?;
8
    Ok(contents)
9
}
10

11
fn divide(a: i32, b: i32) -> Result<i32, String> {
12
    if b == 0 { Err("除数不能为0".to_string()) } else { Ok(a / b) }
13
}
14

15
fn main() {
16
    // Result 错误处理
17
    match divide(10, 0) {
18
        Ok(v) => println!("结果 = {}", v),
19
        Err(e) => println!("错误 = {}", e),
20
    }
21

22
    // 使用 ? 错误传播
23
    match read_file("test.txt") {
24
        Ok(text) => println!("文件内容 = {}", text),
25
        Err(e) => println!("文件读取错误 = {}", e),
26
    }
27
}