30天拿下Rust之错误处理

概述

    在软件开发领域，对错误的妥善处理是保证程序稳定性和健壮性的重要环节。Rust作为一种系统级编程语言，以其对内存安全和所有权的独特设计而著称，其错误处理机制同样体现了Rust的严谨与实用。在Rust中，错误处理通常分为两大类：不可恢复的错误和可恢复的错误。这两种错误的处理方式在Rust的设计哲学中扮演着不同的角色，并且适用于不同的场景。

不可恢复的错误

    不可恢复的错误是指那些由于严重问题，导致程序无法继续执行的情况。这类错误通常是由于编程错误、资源耗尽、或者外部系统问题导致的。在Rust中，不可恢复的错误通过panic!宏来触发。

    当panic!被调用时，程序会立即停止当前的执行流程，并打印出一条错误消息，然后退出程序。因为panic!会导致程序崩溃，所以它通常只在开发过程中用于检测那些不应该发生的严重错误。

    在下面的示例代码中，如果除数b为0，会通过panic!宏来触发不可恢复的错误，并打印错误消息“Division by zero”。panic!被调用后，程序会立即终止，因此，后面的println!不会执行。

fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Division by zero");
    }
    a / b
}

fn main() {
    let value = divide(66, 0);
    println!("{}", value);
}

    注意：在生产代码中，应当尽量避免使用panic!，因为它会导致程序不稳定和不可靠。相反，应该使用下面介绍的可恢复的错误机制来优雅地处理可能出现的错误，并确保程序在遇到问题时，能够以一种可预测和可控的方式做出响应。

可恢复的错误

    可恢复的错误是指那些可以通过某种方式修正或处理的错误，通常不会导致程序完全崩溃。在Rust中，这类错误通常通过Result枚举类型来表示。Result有两个可能的变体：Ok用于表示操作成功的结果，而Err用于表示错误。

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

    使用Result枚举类型，函数可以显式地表示它们可能失败，并返回一个错误值。调用这些函数的代码，可以选择如何处理这些错误，比如：重试、提供默认值、或者将错误传递给上层调用者。这种错误处理机制允许程序在发生错误时保持运行，并可能从错误中恢复。

    在下面的示例代码中，我们调用File::open方法尝试打开名为“CSDN.txt”的文件。这个方法返回一个Result类型，其中Ok变体包含文件句柄（如果文件打开成功），而Err变体包含错误信息（如果文件打开失败）。

use std::fs::File;

fn main() {
    let file_handle = File::open("CSDN.txt");
    match file_handle {
        Ok(file) => {
            println!("open successfully");
        },
        Err(err) => {
            println!("failed: {}", err);
        }
    }
}

    如果想将一个可恢复的错误按照不可恢复的错误处理，Result类提供了两个方法：unwrap()和expect()。这两个方法是用于处理Result或Option类型的便捷方法，用于从这些类型中提取出内部值，但当值不存在（对于Option）或是一个错误状态（对于Result）时，都会导致程序panic。如果Option是None或者Result是Err(E)，则unwrap()会触发panic，并打印出默认的panic!消息。expect()方法与unwrap()方法类似，但它允许我们自定义在panic时输出的错误消息。

fn main() {
    let opt_value: Option<i32> = Some(66);
    let value = opt_value.unwrap();
    println!("{}", value);

    let result: Result<i32, String> = Err("not valid".to_string());
    result.expect("failed");
}

    注意：在非生产环境或者确定不会出现错误的情况下可以使用unwrap()方法和expect()方法，但在实际项目开发中应尽量避免。

?运算符

    Rust提供了一个便捷的?运算符，用于简洁地传播错误。当Result类型变量出现在?后面时，如果它是Ok值，则解包其内部的值；如果是Err值，则从当前函数返回该错误。

    在下面的示例代码中，?操作符用于简化错误处理。如果在其前面的操作File::open和read_to_string返回Err变体，则整个表达式会立即返回该错误。这使得代码更加简洁，但也可能隐藏一些复杂的错误处理逻辑。在需要更精细控制错误处理的情况下，应该使用完整的match表达式或if let语句。

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

fn read_file(filename: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(filename)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    let result = read_file("CSDN.txt");
    match result {
        Ok(contents) => println!("content is: {}", contents),
        Err(e) => {
            println!("read file failed: {}", e);
        }
    }
}

自定义错误

    在Rust中，可以通过实现std::error::Error trait来创建自定义错误类型。这允许我们定义自己的错误类型，并能够更具体地描述程序中可能发生的错误情况。

    自定义错误类型通常包含一个或多个字段，这些字段可以包含有关错误的额外信息。通过实现Error trait，我们可以控制错误消息的格式，并且错误类型可以与其他期望Error trait的Rust错误处理机制一起工作。

    在下面的示例代码中，MyCustomError是一个简单的结构体，它包含一个描述错误的String字段。我们实现了Error trait，使得MyCustomError可以作为错误类型被使用。此外，我们还实现了fmt::Display trait，以定义错误打印时应该显示的字符串。process函数模拟了一些可能失败的操作，并在失败时返回一个MyCustomError实例。在main函数中，我们调用process函数并处理其返回的结果，并打印输出相应的信息。

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

// 自定义错误类型
#[derive(Debug)]
struct MyCustomError {
    desc: String,
}  
  
// 实现Error trait
impl Error for MyCustomError {}

// 实现Display trait
impl fmt::Display for MyCustomError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.desc)
    }
}

fn process() -> Result<(), MyCustomError> {
    Err(MyCustomError {
        desc: "something is wrong".to_string(),
    })
}

fn main() {
    match process() {
        Ok(()) => println!("success"),
        Err(e) => {
            println!("failed: {}", e);
        }  
    }
}