Rust 常用语法速记 - 错误处理

Rust 的错误处理机制是其语言设计中的重要组成部分，强调显式、安全地处理可能出现的错误，而不是依赖异常机制。这使得 Rust 程序更加健壮和可靠。

1. 错误类型概述

Rust 将错误分为两大类：可恢复错误 （Recoverable Errors）和不可恢复错误（Unrecoverable Errors）。

错误类型	处理方式	适用场景
可恢复错误	`Result<T, E>`	文件未找到、网络连接中断等可预料且能处理的错误
不可恢复错误	`panic!`	数组越界、空指针解引用等严重程序错误

2. Result 类型

Result<T, E>是 Rust 标准库中的一个枚举类型，用于处理可恢复错误：

rust 复制代码

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

基本使用示例

rust 复制代码

use std::fs::File;  
  
fn main() {  
    let f = File::open("hello.txt");  
  
    match f {  
        Ok(file) => println!("文件打开成功: {:?}", file),  
        Err(error) => println!("打开文件失败: {}", error),  
    };  
}

3. 错误传播与 ? 操作符

?操作符是 Rust 错误处理的语法糖，它自动处理 Result的传播，使代码更简洁。

使用对比

rust 复制代码

use std::fs::File;  
use std::io::Read;  
  
fn main() {  
    let path = "hello.txt";  
    let result = read_file_manual(path);  
    match result {  
        Ok(result) => println!("结果: {}", result),  
        Err(e) => println!("错误: {}", e),  
    }  
  
    let result = read_file_simple(path);  
    match result {  
        Ok(result) => println!("结果: {}", result),  
        Err(e) => println!("错误: {}", e),  
    }  
}  
  
// 传统 match 方式  
fn read_file_manual(path:&str) -> Result<String,std::io::Error>{  
    let mut file = match File::open(path) {  
        Ok(f) => f,  
        Err(e) => return Err(e),  
    };  
  
    let mut content = String::new();  
    match file.read_to_string(&mut content) {  
        Ok(_) => Ok(content),  
        Err(e) => Err(e),  
    }  
}  
  
// 使用 ? 操作符  
fn read_file_simple(path:&str) -> Result<String,std::io::Error>{  
    let mut file = File::open(path)?;  
    let mut content = String::new();  
    file.read_to_string(&mut content)?;  
    Ok(content)  
}

输出：

lua 复制代码

项目目录是这样的,hello.txt里面的内容是 Hello,World
src
│   └── main.rs
Cargo.lock
Cargo.toml
hello.txt

当path = "hello.txt" 时,输出:
结果: Hello,World
结果: Hello,World

当path = "hello1.txt" 时,输出:
错误: 系统找不到指定的文件。 (os error 2)
错误: 系统找不到指定的文件。 (os error 2)

4. Result 组合器方法

Result提供了多种组合器方法，用于以函数式风格处理错误。

方法	描述	使用场景
`map`	对 `Ok`值进行转换	成功时转换值，保持错误不变
`map_err`	对 `Err`值进行转换	错误类型转换
`and_then`	链式操作	多个可能失败的操作串联
`or_else`	错误恢复	尝试替代方案
`unwrap_or`	解包或返回默认值	提供备选值
`unwrap_or_else`	解包或计算默认值	需要计算备选值

组合器使用示例

rust 复制代码

use std::num::ParseIntError;  
  
fn main() {  
    let result = parse_and_double("12");  
    match result {  
        Ok(result) => println!("结果: {}", result),  
        Err(e) => println!("错误: {}", e),  
    }  
  
    let result = process_numbers("12", "12");  
    match result {  
        Ok(result) => println!("结果: {}", result),  
        Err(e) => println!("错误: {}", e),  
    }  
}  
  
  
fn parse_and_double(s: &str) -> Result<i32, ParseIntError> {  
    s.parse::<i32>()  
        .map(|n| n * 2)  
        .map_err(|e| {  
            println!("解析错误: {}", e);  
            e  
        })  
}  
  
fn process_numbers(a: &str, b: &str) -> Result<i32, String> {  
    let num_a = a.parse::<i32>().map_err(|e| e.to_string())?;  
    let num_b = b.parse::<i32>().map_err(|e| e.to_string())?;  
    Ok(num_a + num_b)  
}

输出：

makefile 复制代码

在传入的都为 12 时,输出:
结果: 24
结果: 24

如果传入的其中有无法转成数字类型的,输出:
解析错误: invalid digit found in string
错误: invalid digit found in string
错误: invalid digit found in string

5. 自定义错误类型

对于复杂应用，创建统一的错误类型是最佳实践。

手动实现自定义错误

rust 复制代码

use std::error::Error;
use std::{fmt, io, num};
use std::fmt::{Formatter};
use std::num::ParseIntError;

fn main() {

    //使用示例
    let result = read_and_parse_config("hello.txt");

    match result {
        Ok(value) => println!("成功读取配置值: {}", value),
        Err(e) => {

            match e {
                AppError::IoError(io_err) => {
                    eprintln!("文件操作失败: {}", io_err);
                }
                AppError::ParseError(parse_err) => {
                    eprintln!("解析内容失败: {}", parse_err);
                }
                AppError::ConfigError(msg) => {
                    eprintln!("配置无效: {}", msg);
                }
            }
        }
    }

}

//使用示例
fn read_and_parse_config(file_path:&str) -> AppResult<i32>{

    // 1. 读取文件内容：? 运算符会自动将 io::Error 通过 From trait 转换为 AppError::IoError
    let content = std::fs::read_to_string(file_path)?;

    // 2. 检查是否为空，模拟一个自定义错误
    if content.trim().is_empty() {
        return Err(AppError::ConfigError("配置文件为空".to_string()));
    }

    // 3. 解析内容为整数：? 运算符会自动将 ParseIntError 转换为 AppError::ParseError
    let num = content.trim().parse::<i32>()?;

    // 4. 额外的业务逻辑检查
    if num < 0 {
        return Err(AppError::ConfigError("配置不能为复数".to_string()));
    }

    Ok(num)
}


fn print_error_chain(error: &dyn std::error::Error) {
    eprintln!("错误: {}", error);
    let mut source = error.source();

    while let Some(s) = source {
        eprintln!("  原因: {}", s);
        source = s.source();
    }
}



#[derive(Debug)]
enum AppError {
    IoError(io::Error),
    ParseError(num::ParseIntError),
    ConfigError(String),
}


//实现 Display trait
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            AppError::IoError(err) => write!(f, "IO错误: {}", err),
            AppError::ParseError(err) => write!(f, "解析错误: {}", err),
            AppError::ConfigError(msg) => write!(f, "配置错误: {}", msg),
        }
    }
}

// 实现 Error trait
impl Error for AppError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            AppError::IoError(err) => Some(err),
            AppError::ParseError(err) => Some(err),
            AppError::ConfigError(_) => None,
        }
    }
}

//实现从其他错误类型的转换
impl From<io::Error> for AppError{
    fn from(err: io::Error) -> Self {
        AppError::IoError(err)
    }
}

impl From<num::ParseIntError> for AppError{
    fn from(err: ParseIntError) -> Self {
        AppError::ParseError(err)
    }
}


type AppResult<T> = Result<T, AppError>;

错误链追踪

rust 复制代码

fn print_error_chain(error: &dyn std::error::Error) {
    eprintln!("错误: {}", error);
    let mut source = error.source();
    while let Some(s) = source {
        eprintln!("  原因: {}", s);
        source = s.source();
    }
}

// 在主函数中可以这样使用
match read_and_parse_config("hello.txt") {
    Ok(value) => println!("成功: {}", value),
    Err(e) => print_error_chain(&e),
}

使用 thiserror 库简化

添加 thiserror 依赖

toml 复制代码

[dependencies]
thiserror = "1.0"

thiserror库可以大大简化自定义错误类型的定义：

rust 复制代码

use std::{io, num};
use thiserror::Error;

fn main() {

    // 在主函数中可以这样使用
    match read_and_parse_config("hello.txt") {
        Ok(value) => println!("成功: {}", value),
        Err(e) => print_error_chain(&e),
    }
}

//使用示例
fn read_and_parse_config(file_path:&str) -> AppResult<i32>{

    // 1. 读取文件内容：? 运算符会自动将 io::Error 通过 From trait 转换为 AppError::IoError
    let content = std::fs::read_to_string(file_path)?;

    // 2. 检查是否为空，模拟一个自定义错误
    if content.trim().is_empty() {
        return Err(AppError::ConfigError("配置文件为空".to_string()));
    }

    // 3. 解析内容为整数：? 运算符会自动将 ParseIntError 转换为 AppError::ParseError
    let num = content.trim().parse::<i32>()?;

    // 4. 额外的业务逻辑检查
    if num < 0 {
        return Err(AppError::ConfigError("配置不能为复数".to_string()));
    }

    Ok(num)
}

fn print_error_chain(error: &dyn std::error::Error) {
    eprintln!("错误: {}", error);
    let mut source = error.source();
    while let Some(s) = source {
        eprintln!("  原因: {}", s);
        source = s.source();
    }
}

#[derive(Error, Debug)]
enum AppError{

    #[error("IO错误: {0}")]
    IoError(#[from] io::Error),

    #[error("解析错误: {0}")]
    ParseError(#[from] num::ParseIntError),

    #[error("配置错误: {0}")]
    ConfigError(String),

}

type AppResult<T> = Result<T, AppError>;

核心语法解析

代码部分	含义与作用	说明
`#[derive(Error, Debug)]`	派生宏。`Debug`使错误可打印用于调试；`Error`（来自 `thiserror`）自动为你实现 `std::error::Error`trait。	`thiserror`宏会帮你生成大量样板代码，无需手动实现 `Display`、`Error`以及 `From`等 trait。
`enum AppError { ... }`	定义一个枚举类型，列举所有可能的错误变体。	使用枚举是 Rust 中表示多种错误类型的常见方式。
`#[error("IO错误: {0}")]`	属性宏。定义该错误变体的显示信息。`{0}`是一个占位符，会被变体第一个字段的值替换。	为变体自动生成 `Display`trait 的实现。消息格式灵活，支持索引（`{0}`）、命名字段（`{field}`）等。
`IoError(#[from] io::Error)`	元组变体。包含一个 `io::Error`类型的字段。`#[from]`属性表明会自动实现 `From<io::Error> for AppError`，允许使用 `?`自动转换。	`#[from]`属性极大地简化了错误转换和传播的代码。
`ConfigError(String)`	元组变体。包含一个 `String`类型字段，用于传递自定义的错误消息。	这种变体适合那些没有标准错误类型对应、需要自定义错误信息的场景。

6. 使用 anyhow 库

添加 anyhow 依赖

toml 复制代码

[dependencies]
anyhow = "1.0"

对于应用程序开发，anyhow库提供了一种轻量级的错误处理方案，允许跳过自定义错误类型的定义。

rust 复制代码

use anyhow::{Context, Result};

fn main() -> Result<()> {
    let number = read_number("hello.txt")?;
    println!("读取到的数字: {}", number);
    Ok(())
}

fn read_number(path:&str) -> Result<i32>{

    let content = std::fs::read_to_string(path).context("文件读取失败")?;

    let number = content.trim().parse::<i32>().context("数值解析失败")?;

    Ok(number)
}

7. panic! 与不可恢复错误

对于不可恢复错误，Rust 提供了 panic!宏。

rust 复制代码

fn main() {
    // 显式调用 panic!
    //panic!("这是一个不可恢复错误");

    // 数组越界访问会导致 panic
    let v = vec![1, 2, 3];
    // 这将导致 panic!
    println!("{}", v[99]);
}

8. 错误处理对比

策略	主要适用场景	核心优点	主要缺点 / 注意事项
`panic!`	不可恢复的错误、原型开发、测试代码、程序启动时关键配置验证或资源初始化失败	简单直接，立即终止程序防止状态不一致	程序终止，不够优雅，生产环境应避免滥用，仅用于"不可能发生"的错误或导致程序无法继续运行的严重问题
`Result`	可恢复的错误（主流场景）	强制显式处理，类型安全，编译期确保错误得到处理	代码相比 `panic`稍显冗长（但可通过 `?`等方式极大简化）
`Option`	可选值，值可能存在也可能不存在的情况	简单明了，无需错误信息时很轻量	无法携带错误信息，只表示"有无"，不说明"为何没有"
自定义错误	复杂应用、库开发	统一错误类型，提供丰富上下文和结构化错误信息，增强API的清晰度	需要额外代码来定义错误类型并实现相关 trait（但可通过 `thiserror`等库简化）
`anyhow`	应用程序开发、脚本、命令行工具	快速实现错误处理，减少样板代码，方便添加上下文信息 (`context()`)	错误类型是动态的 (`anyhow::Error`)，调用者无法进行精确的模式匹配
`thiserror`	库开发、需要精确错误类型的应用程序	简化自定义错误类型的定义，生成结构化、可精确匹配的错误类型，与 `?`无缝集成	相比 `anyhow`需要预先定义错误枚举类型

补充说明:

panic!的使用需要特别谨慎 。它更像是一种"紧急制动"，用于处理那些不应该发生、一旦发生程序就无法或不应继续执行的情况。在库代码中，通常应避免使用 panic!，除非是触发了库合约（contract）的严重违反。
Result和 Option是基础 ，它们不是互斥的，而是用于不同场景。Option用于值的缺失，Result用于操作的失败。
anyhow和 thiserror不是替代关系，而是互补关系，它们适用于不同的开发场景：

anyhow 适用于应用程序，你关心的是错误信息本身和快速开发，不关心错误的精确类型
thiserror 适用于库和需要明确错误类型的模块，你希望为用户提供可以稳定匹配和处理的错误变体

错误传播的利器?运算符 ：表格中没有单独列出 ?，但它几乎是使用 Result、anyhow::Result和通过 thiserror定义的自定义错误时的"标配"。它极大地简化了错误传播的代码。
组合器方法 ：Result提供了丰富的组合器方法（如 map, map_err, and_then, or_else, unwrap_or等），用于以函数式风格处理错误，有时比 match更简洁。

9. 实战示例：文件处理

rust 复制代码

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

fn main() -> Result<(), io::Error> {
    process_file("input.txt", "output.txt")?;
    println!("文件处理完成");
    Ok(())
}


fn process_file(input_path: &str, output_path: &str) -> Result<(), io::Error> {
    // 读取输入文件
    let mut input = File::open(input_path)?;
    let mut content = String::new();
    input.read_to_string(&mut content)?;

    // 处理内容（示例：转换为大写）
    let processed = content.to_uppercase();

    // 写入输出文件
    let mut output = File::create(output_path)?;
    output.write_all(processed.as_bytes())?;

    Ok(())
}

Rust 的错误处理机制通过类型系统和简洁的语法，使开发者能够编写出既可靠又易维护的代码。掌握这些模式后，会发现 Rust 代码在表达力与健壮性之间的完美平衡。