Rust 中的可恢复错误处理：用 `Result` 枚举优雅地管理失败_rust 错误处理 result的好处是什么-CSDN博客

本文链接：https://blog.csdn.net/weixin_43114209/article/details/145439397

1. 理解 `Result` 枚举

Rust 中的 Result 枚举定义如下：

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

Ok(T) 表示操作成功，并包含一个类型为 T 的值。
Err(E) 表示操作失败，并包含一个类型为 E 的错误信息。

这使得同一个错误处理机制能够适用于各种场景：无论你在读取文件、解析数据还是进行网络请求，都可以统一返回一个 Result 类型，供调用者进一步处理。

例如，当我们调用 File::open("hello.txt") 时，其返回类型是 Result<std::fs::File, std::io::Error>。成功时返回一个文件句柄，失败时返回一个描述错误的 io::Error 实例。

2. 使用 `match` 处理 `Result`

最基本的错误处理方式是使用 match 表达式。考虑下面的示例，我们尝试打开一个文件，并对返回的 Result 进行匹配：

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

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => {
            // 对不同错误情况进行处理，例如这里选择 panic
            panic!("Problem opening the file: {:?}", error);
        },
    };

    // 此处可以继续使用 greeting_file 进行后续操作…
}

在这个示例中，如果文件存在并成功打开，我们将文件句柄绑定到 greeting_file；否则程序会调用 panic! 终止执行，并打印出详细的错误信息。

3. 针对不同错误做出不同响应

有时候，我们希望对不同类型的错误采取不同的应对策略。比如，如果文件不存在，我们可能希望先创建它，而对于其他错误（比如权限不足）则依然让程序 panic。可以通过嵌套 match 来实现：

use std::fs::File;
use std::io;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => {
                panic!("Problem opening the file: {:?}", other_error);
            }
        },
    };

    // 后续使用 greeting_file 进行文件操作
}

这里通过 error.kind() 判断错误类型，如果是 NotFound（文件不存在），则尝试创建文件；否则直接 panic。

4. 快捷方法：`unwrap` 与 `expect`

使用 match 处理 Result 很灵活，但有时显得过于冗长。Rust 为 Result 提供了两个常用的快捷方法：

unwrap
如果 Result 为 Ok，则返回内部的值；如果为 Err，则调用 panic! 并输出默认错误信息。
```
use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}
```

expect
与 unwrap 类似，不过允许你自定义错误信息，使得在 panic 时更容易调试。

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be present in the project directory");
}

在生产代码中，很多 Rustaceans 更倾向于使用 expect，因为它可以提供更详细的上下文信息，帮助定位问题。

5. 错误传播：使用 `?` 运算符

当一个函数调用可能失败时，我们可以选择在该函数内部处理错误，或将错误“传播”给调用者，让调用者来决定如何处理。Rust 提供了非常简洁的 ? 运算符来实现错误传播。使用 ? 运算符可以自动地检测 Result 值：

如果是 Ok，则提取内部的值并继续执行；
如果是 Err，则提前返回该错误给调用者。

下面是一个使用 ? 运算符的示例，它尝试从文件中读取用户名：

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

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("hello.txt")?;
    let mut username = String::new();
    file.read_to_string(&mut username)?;
    Ok(username)
}

fn main() {
    match read_username_from_file() {
        Ok(name) => println!("Username: {}", name),
        Err(e) => println!("Error reading username: {:?}", e),
    }
}

在这个函数中，两个 ? 运算符依次用于 File::open 和 read_to_string。如果任何一步出错，错误都会被自动返回，省去了大量冗余的 match 代码。

为了进一步简化，标准库还提供了 fs::read_to_string 这样的一步到位的函数，它内部就使用了 ? 运算符来完成相同的操作：

use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}

6. 在 `main` 函数中使用 `?` 运算符

默认情况下，main 函数的返回类型是 (), 但如果我们希望在 main 中使用 ? 运算符，可以将 main 的返回类型设为 Result<(), E>。例如：

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

fn main() -> Result<(), Box<dyn Error>> {
    let mut file = File::open("hello.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    println!("File contents: {}", contents);
    Ok(())
}