Rust 错误处理

在 Rust 中，错误处理是编程过程里极为重要的一部分，它提供了多种机制来有效地处理程序运行时可能出现的各种错误情况，确保程序的健壮性和稳定性。

下面详细介绍 Rust 中常见的错误处理方式。

1. panic! 宏

panic! 宏用于处理那些程序无法继续运行下去的严重错误。当调用 panic! 时，程序会打印错误信息，展开并清理调用栈，最后终止程序。

示例代码

fn main() { 
    // 主动触发 panic 
    panic!("This is a panic situation!"); 
} 

在实际开发中，panic! 也可能在一些内置操作出错时自动触发，比如访问数组越界：

fn main() { 
    let v = vec![1, 2, 3]; 
    // 访问越界，会触发 panic 
    let element = v[10]; 
} 

2. Result 枚举

Result 是一个非常常用的枚举类型，定义在标准库中，用于处理可能出错的操作。它有两个变体：Ok(T) 表示操作成功并返回结果 T，Err(E) 表示操作失败并返回错误信息 E。

基本定义

enum Result<T, E> { 
    Ok(T), 
    Err(E), 
} 

示例代码

fn divide(a: i32, b: i32) -> Result<i32, &'static str> { 
    if b == 0 { 
        Err("Division by zero is not allowed!") 
    } else { 
        Ok(a / b) 
    } 
} 

fn main() { 
    let result = divide(10, 2); 
    match result { 
        Ok(value) => println!("The result of division is: {}", value), 
        Err(msg) => println!("Error: {}", msg), 
    } 
} 

unwrap 和 expect 方法

unwrap 和 expect 是 Result 类型提供的便捷方法，用于从 Ok 变体中提取值。如果是 Err 变体，unwrap 会触发 panic!，expect 同样会触发 panic! 但可以自定义错误信息。

fn divide(a: i32, b: i32) -> Result<i32, &'static str> { 
    if b == 0 { 
        Err("Division by zero is not allowed!") 
    } else { 
        Ok(a / b) 
    } 
} 
fn main() { 
    let result1 = divide(10, 2).unwrap(); 
    println!("Result 1: {}", result1); 
    // 会触发 panic 
    let result2 = divide(10, 0).expect("Failed to perform division"); 
} 

3. Option 枚举

Option 枚举用于处理可能没有值的情况，它有两个变体：Some(T) 表示存在值 T，None 表示没有值。虽然它本身不是专门用于错误处理，但在很多场景下可以和错误处理结合使用。

基本定义

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

示例代码

fn get_element(v: &[i32], index: usize) -> Option<&i32> { 
    if index < v.len() { 
        Some(&v[index]) 
    } else { 
        None 
    } 
} 
fn main() { 
    let v = vec![1, 2, 3]; 
    let element = get_element(&v, 1); 
    match element { 
        Some(value) => println!("The element is: {}", value), 
        None => println!("Index out of bounds"), 
    } 
} 

unwrap 和 expect 方法

Option 类型也有 unwrap 和 expect 方法，功能和 Result 类型类似。当 Option 是 Some 时，会提取其中的值；当是 None 时，会触发 panic!。

fn get_element(v: &[i32], index: usize) -> Option<&i32> { 
    if index < v.len() { 
        Some(&v[index]) 
    } else { 
        None 
    } 
} 
fn main() { 
    let v = vec![1, 2, 3]; 
    let element1 = get_element(&v, 1).unwrap(); 
    println!("Element 1: {}", element1); 
    // 会触发 panic 
    let element2 = get_element(&v, 10).expect("Failed to get element"); 
} 

4. ? 运算符

? 运算符是 Rust 中一个非常方便的错误处理语法糖，它只能用在返回 Result 或 Option 类型的函数中。当遇到 Ok 或 Some 时，会提取其中的值继续执行；当遇到 Err 或 None 时，会直接从当前函数返回该错误。

示例代码

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

fn read_file() -> Result<String, io::Error> { 
    let mut file = File::open("example.txt")?; 
    let mut contents = String::new(); 
    file.read_to_string(&mut contents)?; 
    Ok(contents) 
} 
fn main() { 
    match read_file() { 
        Ok(text) => println!("File contents: {}", text), 
        Err(err) => println!("Error reading file: {}", err), 
    } 
} 

5. 自定义错误类型

在实际项目中，可能需要自定义错误类型来更清晰地表达不同的错误情况。可以通过实现 std::error::Error trait 来创建自定义错误类型。

示例代码

use std::error::Error; 
use std::fmt; 
// 自定义错误类型 
#[derive(Debug)] 
struct MyError { 
    details: String, 
} 
impl MyError { 
    fn new(msg: &str) -> MyError { 
        MyError { 
            details: msg.to_string(), 
        } 
    } 
} 

impl fmt::Display for MyError { 
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 
        write!(f, "{}", self.details) 
    } 
} 

impl Error for MyError {} 

fn do_something() -> Result<(), MyError> { 
    Err(MyError::new("This is a custom error!")) 
} 

fn main() { 
    match do_something() { 
        Ok(_) => println!("Operation succeeded"), 
        Err(err) => println!("Error: {}", err), 
    } 
} 

6. anyhow 和 thiserror 库

对于更复杂的错误处理，可以使用 anyhow 和 thiserror 这两个流行的库。

• anyhow 提供了一个通用的 Error 类型，适合用于应用程序中的错误处理。
• thiserror 提供了一个派生宏，用于方便地定义自定义错误类型。

使用 thiserror

use thiserror::Error;

#[derive(Error, Debug)]
enum MyError {
    #[error("Division by zero")]
    DivisionByZero,
    #[error("Negative number")]
    NegativeNumber,
}

fn divide(a: i32, b: i32) -> Result<i32, MyError> {
    if b == 0 {
        return Err(MyError::DivisionByZero);
    }
    if a < 0 || b < 0 {
        return Err(MyError::NegativeNumber);
    }
    Ok(a / b)
}

fn main() {
    match divide(10, 0) {
        Ok(value) => println!("Result: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

使用 anyhow

use anyhow::{Result, Context};

fn divide(a: i32, b: i32) -> Result<i32> {
    if b == 0 {
        return Err(anyhow::anyhow!("Division by zero"));
    }
    Ok(a / b)
}

fn main() -> Result<()> {
    let result = divide(10, 0).context("Failed to divide")?;
    println!("Result: {}", result);
    Ok(())
}

这些错误处理机制为 Rust 开发者提供了丰富的工具，能够根据不同的场景选择最合适的方式来处理错误，保证程序的正确性和可靠性。