Rust 错误处理

目录

• 用 panic! 处理不可恢复的错误
  
• 对应 panic 时的栈展开或终止
  
  
  
  • 使用 panic! 的 backtrace
    
    
    
    • Windows设置 RUST_BACKTRACE 环境变量的两种方式
      
    
    
  
  
• 用 Result 处理可恢复的错误
  
  
  
  • 匹配不同的错误
    
    
    
    • 不同于使用 match 和 Result
      
    
    
  • 失败时 panic 的简写：unwrap 和 expect
    
  • 传播错误
    
  • 传播错误的简写：? 运算符
    
  • 哪里可以使用 ? 运算符
    
  
  
• 要不要 panic!
  
  
  
  • 示例、代码原型和测试都非常适合 panic
    
  • 当我们比编译器知道更多的情况
    
  • 错误处理指导原则
    
  • 创建自定义类型进行有效性验证
    
  
  

本文略有删减，原文请访问错误处理。
panic! 宏代表一个程序无法处理的状态，并停止执行而不是使用无效或不正确的值继续处理。
Rust 类型系统的 Result 枚举代表操作可能会在一种可以恢复的情况下失败，可以使用 Result 来告诉代码调用者他需要处理潜在的成功或失败。
用 panic! 处理不可恢复的错误

在实践中有两种方法造成 panic：执行会造成代码 panic 的操作（比如访问超过数组结尾的内容）或者显式调用 panic! 宏。

对应 panic 时的栈展开或终止

当出现 panic 时，程序默认会开始 展开（unwinding），这意味着 Rust 会回溯栈并清理它遇到的每一个函数的数据，不过这个回溯并清理的过程有很多工作。另一种选择是直接 终止（abort），这会不清理数据就退出程序，程序所使用的内存需要由操作系统来清理。
如果需要项目的最终二进制文件越小越好，panic 时通过在 Cargo.toml 的 [profile] 部分增加 panic = 'abort'，可以由展开切换为终止，如在 release 模式中 panic 时直接终止：

1. [profile.release]
2. panic = 'abort'

复制代码

在一个简单的程序中调用 panic!：

1. fn main() {
2.     panic!("crash and burn");
3. }

复制代码

使用 panic! 的 backtrace

让我们来看看另一个因为我们代码中的 bug 引起的别的库中 panic! 的例子，而不是直接的宏调用。
尝试访问超越 vector 结尾的元素，这会造成 panic!：

1. fn main() {
2.     let v = vec![1, 2, 3];
4.     v[99];
5. }

复制代码

可以设置 RUST_BACKTRACE 环境变量来得到一个 backtrace，backtrace 是一个执行到目前位置所有被调用的函数的列表。Rust 的 backtrace 跟其他语言中的一样：阅读 backtrace 的关键是从头开始读直到发现你编写的文件。
将 RUST_BACKTRACE 环境变量设置为任何不是 0 的值来获取 backtrace 看看：

1. $ RUST_BACKTRACE=1 cargo run
2. thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
3. stack backtrace:
4.    0: rust_begin_unwind
5.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/std/src/panicking.rs:584:5
6.    1: core::panicking::panic_fmt
7.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:142:14
8.    2: core::panicking::panic_bounds_check
9.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:84:5
10.    3: <usize as core::slice::index::SliceIndex<[T]>>::index
11.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:242:10
12.    4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
13.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:18:9
14.    5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
15.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/alloc/src/vec/mod.rs:2591:9
16.    6: panic::main
17.              at ./src/main.rs:4:5
18.    7: core::ops::function::FnOnce::call_once
19.              at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/ops/function.rs:248:5
20. note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

复制代码

为了获取带有这些信息的 backtrace，必须启用 debug 标识。当不使用 --release 参数运行 cargo build 或 cargo run 时 debug 标识会默认启用，就像这里一样。
Windows设置 RUST_BACKTRACE 环境变量的两种方式

在cmd中执行

1. set RUST_BACKTRACE=1

复制代码

在powershell中执行：

1. $env:RUST_BACKTRACE=1 ; cargo run

复制代码

用 Result 处理可恢复的错误

使用 Result 类型来处理潜在的错误中的那个 Result 枚举，它定义有Ok 和 Err两个成员：

1. enum Result<T, E> {
2.     Ok(T),
3.     Err(E),
4. }

复制代码

T 和 E 是泛型类型参数：

• T 代表成功时返回的 Ok 成员中的数据的类型
  
• E 代表失败时返回的 Err 成员中的错误的类型
  

调用一个返回 Result 的函数，它打开一个文件，可能会失败：

1. use std::fs::File;
3. fn main() {
4.     let greeting_file_result = File::open("hello.txt");
5. }

复制代码

File:pen 的返回值是 Result：

• 泛型参数 T 会被 File:pen 的实现放入成功返回值的类型 std::fs::File，这是一个文件句柄。
  
• 错误返回值使用的 E 的类型是 std::io::Error。
  

`File:pen`` 调用可能成功并返回一个可以读写的文件句柄，也可能会失败，如文件不存在或无访问权限。
需要在代码中增加根据 File:pen 返回值进行不同处理的逻辑：

1. use std::fs::File;
3. fn main() {
4.     let greeting_file_result = File::open("hello.txt");
6.     let greeting_file = match greeting_file_result {
7.         Ok(file) => file,
8.         Err(error) => panic!("Problem opening the file: {:?}", error),
9.     };
10. }

复制代码

如果当前目录没有一个叫做 hello.txt 的文件，当运行这段代码时 panic! 宏的输出能告诉了我们出错的地方。
匹配不同的错误

使用不同的方式处理不同类型的错误：

1. use std::fs::File;
2. use std::io::ErrorKind;
4. fn main() {
5.     let greeting_file_result = File::open("hello.txt");
7.     let greeting_file = match greeting_file_result {
8.         Ok(file) => file,
9.         Err(error) => match error.kind() {
10.             //尝试打开的文件并不存在，通过 File::create 创建文件
11.             ErrorKind::NotFound => match File::create("hello.txt") {
12.                 Ok(fc) => fc,
13.                 Err(e) => panic!("Problem creating the file: {:?}", e),
14.             },
15.             other_error => {
16.                 panic!("Problem opening the file: {:?}", other_error);
17.             }
18.         },
19.     };
20. }

复制代码

• File:pen 返回的 Err 成员中的值类型 io::Error，它是一个标准库中提供的结构体。
  
• io::Error 结构体有一个返回 io::ErrorKind 值的 kind 方法可供调用。
  
• io::ErrorKind 是一个标准库提供的枚举，它的成员对应 io 操作可能导致的不同错误类型。
  

不同于使用 match 和 Result

在处理代码中的 Result 值时，相比于使用 match ，使用闭包和 unwrap_or_else 方法会更加简洁：

1. use std::fs::File;
2. use std::io::ErrorKind;
4. fn main() {
5.     let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
6.         if error.kind() == ErrorKind::NotFound {
7.             File::create("hello.txt").unwrap_or_else(|error| {
8.                 panic!("Problem creating the file: {:?}", error);
9.             })
10.         } else {
11.             panic!("Problem opening the file: {:?}", error);
12.         }
13.     });
14. }

复制代码

失败时 panic 的简写：unwrap 和 expect

Result 类型定义了很多辅助方法来处理各种情况，其中之一叫做 unwrap：

• 如果 Result 值是成员 Ok，unwrap 会返回 Ok 中的值。
  
• 如果 Result 是成员 Err，unwrap 会为我们调用 panic!。
  

一个实践 unwrap 的例子：

1. use std::fs::File;
3. fn main() {
4.     let greeting_file = File::open("hello.txt").unwrap();
5. }

复制代码

另一个类似于 unwrap 的方法它还允许选择 panic! 的错误信息：expect，语法如下：

1. use std::fs::File;
3. fn main() {
4.     let greeting_file = File::open("hello.txt")
5.         .expect("hello.txt should be included in this project");
6. }

复制代码

expect 与 unwrap 的使用方式一样：返回文件句柄或调用 panic! 宏。
在生产级别的代码中，大部分人选择 expect 而不是 unwrap 并提供更多关于为何操作期望是一直成功的上下文。
传播错误

一个从文件中读取用户名的函数，如果文件不存在或不能读取，这个函数会将这些错误返回给调用它的代码：

1. use std::fs::File;
2. use std::io::{self, Read};
4. fn read_username_from_file() -> Result<String, io::Error> {
5.     let username_file_result = File::open("hello.txt");
7.     let mut username_file = match username_file_result {
8.         Ok(file) => file,
9.         Err(e) => return Err(e),
10.     };
12.     let mut username = String::new();
14.     match username_file.read_to_string(&mut username) {
15.         Ok(_) => Ok(username),
16.         Err(e) => Err(e),  //最后一个表达式，无需显式调用 return 语句
17.     }
18. }

复制代码

函数的返回值类型为 Result，说明函数返回一个 Result 类型的值：泛型参数 T 的具体类型是 String，而 E 的具体类型是 io::Error。
这里选择 io::Error 作为函数的返回值是因为它正好是函数体中那两个可能会失败的操作的错误返回值：File:pen 函数和 read_to_string 方法。
传播错误的简写：? 运算符

一个使用 ? 运算符向调用者返回错误的函数：

1. use std::fs::File;
2. use std::io::{self, Read};
4. fn read_username_from_file() -> Result<String, io::Error> {
5.     let mut username_file = File::open("hello.txt")?;
6.     let mut username = String::new();
7.     username_file.read_to_string(&mut username)?;
8.     Ok(username)
9. }

复制代码

Result 值之后的 ? 被定义为与前面示例中定义的处理 Result 值的 match 表达式有着完全相同的工作方式。不同的是，? 运算符所使用的错误值被传递给了 from 函数，它定义于标准库的 From trait 中，其用来将错误从一种类型转换为另一种类型。
问号运算符之后的链式方法调用：

1. use std::fs::File;
2. use std::io::{self, Read};
4. fn read_username_from_file() -> Result<String, io::Error> {
5.     let mut username = String::new();
7.     File::open("hello.txt")?.read_to_string(&mut username)?;
9.     Ok(username)
10. }

复制代码

使用 fs::read_to_string 而不是打开后读取文件

1. use std::fs;
2. use std::io;
4. fn read_username_from_file() -> Result<String, io::Error> {
5.     fs::read_to_string("hello.txt")
6. }

复制代码

哪里可以使用 ? 运算符

? 运算符只能被用于返回值与 ? 作用的值相兼容的函数，因为 ? 运算符被定义为从函数中提早返回一个值，函数的返回值必须是 Result 才能与这个 return 相兼容。
尝试在返回 () 的 main 函数中使用 ? 的代码不能编译：

1. use std::fs::File;
3. fn main() {
4.     let greeting_file = File::open("hello.txt")?;
5. }

复制代码

当编译这些代码时会出错，错误指出只能在返回 Result 或者其它实现了 FromResidual 的类型的函数中使用 ? 运算符。
为了修复这个错误，有两个选择。一个是，如果没有限制的话将函数的返回值改为 Result。另一个是使用 match 或 Result 的方法中合适的一个来处理 Result。
在 Option 上调用 ? 运算符的行为与 Result 类似：如果值是 None，此时 None 会从函数中提前返回。如果值是 Some，Some 中的值作为表达式的返回值同时函数继续。
在 Option 值上使用 ? 运算符：

1. //从给定文本中返回第一行最后一个字符
2. fn last_char_of_first_line(text: &str) -> Option<char> {
3.     text.lines().next()?.chars().last()
4. }

复制代码

注意你可以在返回 Result 的函数中对 Result 使用 ? 运算符，可以在返回 Option 的函数中对 Option 使用 ? 运算符，但是不可以混合搭配。? 运算符不会自动将 Result 转化为 Option，反之亦然；在这些情况下，可以使用类似 Result 的 ok 方法或者 Option 的 ok_or 方法来显式转换。
修改 main 返回 Result 允许对 Result 值使用 ? 运算符：

1. use std::error::Error;
2. use std::fs::File;
4. fn main() -> Result<(), Box<dyn Error>> {
5.     let greeting_file = File::open("hello.txt")?;
7.     Ok(())
8. }

复制代码

目前可以将 Box 理解为 “任何类型的错误”，在返回 Box 错误类型 main 函数中对 Result 使用 ? 是允许的，因为它允许任何 Err 值提前返回。
要不要 panic!

示例、代码原型和测试都非常适合 panic

调用一个类似 unwrap 这样可能 panic! 的方法可以被理解为一个你实际希望程序处理错误方式的占位符，它根据其余代码运行方式可能会各不相同。
在我们准备好决定如何处理错误之前，unwrap和expect方法在原型设计时非常方便。当我们准备好让程序更加健壮时，它们会在代码中留下清晰的标记。
当我们比编译器知道更多的情况

当你有一些其他的逻辑来确保 Result 会是 Ok 值时，调用 unwrap 或者 expect 也是合适的，虽然编译器无法理解这种逻辑：

1. use std::net::IpAddr;
3. let home: IpAddr = "127.0.0.1"
4.     .parse()
5.     .expect("Hardcoded IP address should be valid");

复制代码

可以看出 127.0.0.1 是一个有效的 IP 地址，所以这里使用 expect 是可以接受的。
错误处理指导原则

在当有可能会导致有害状态的情况下建议使用 panic!，有害状态是指当一些假设、保证、协议或不可变性被打破的状态（如无效的值、自相矛盾的值或者被传递了不存在的值），外加如下几种情况：

• 有害状态是非预期的行为，与偶尔会发生的行为相对，比如用户输入了错误格式的数据。
  
• 在此之后代码的运行依赖于不处于这种有害状态，而不是在每一步都检查是否有问题。
  
• 没有可行的手段来将有害状态信息编码进所使用的类型中的情况。
  

当接收到无效输入时，优先返回错误信息以通知用户。若继续执行可能引发安全问题或严重后果，则调用 panic! 停止程序并指出bug。同样，在遇到无法修复的外部代码无效状态时，适宜使用 panic!。
当错误属于预期范围（如解析错误或HTTP限流响应），应返回 Result，表明可能出现失败，并将问题传递给调用者处理。此时不宜使用 panic! 来应对这些情况。
当代码执行操作可能因无效值而危及安全时，应先验证其有效性，并在无效时 panic!。这是因为尝试处理此类数据易暴露漏洞，如数组越界访问会导致 panic! 以防止潜在的安全风险。函数遵循输入条件的契约，若违反契约则通过 panic! 指出调用方 bug，因为这种错误通常无法在函数内部妥善处理，需要程序员修复源代码。函数契约及其可能导致 panic! 的情况应在 API 文档中明确说明。
虽然大量错误检查可能冗长繁琐，但 Rust 的类型系统和编译器能帮你自动进行许多检查。若函数参数为非 Option 类型，编译器确保其非空且有有效值，因此无需在代码中处理 Some/None 情况。传递空值的代码无法通过编译，故函数运行时无须判空。同样，使用如 u32 的无符号整型可确保值永不会为负数。
创建自定义类型进行有效性验证

使用 if 表达式检查值是否超出范围（代码冗余、可能影响性能）：

1. loop {
2.     // --snip--
3.     let guess: i32 = match guess.trim().parse() {
4.         Ok(num) => num,
5.         Err(_) => continue,
6.     };
7.     if guess < 1 || guess > 100 {
8.         println!("The secret number will be between 1 and 100.");
9.         continue;
10.     }
11.     match guess.cmp(&secret_number) {
12.         // --snip--
13. }

复制代码

可以创建一个新类型来将验证放入创建其实例的函数中，而不是到处重复这些检查。这样就可以安全地在函数签名中使用新类型并相信它们接收到的值。
一个 Guess 类型，它只在值位于 1 和 100 之间时才继续：

1. pub struct Guess {
2.     //私有的字段，确保了不会存在没有通过 Guess::new 函数的条件检查的 value
3.     value: i32,
4. }
6. impl Guess {
7.     pub fn new(value: i32) -> Guess {
8.         if value < 1 || value > 100 {
9.             panic!("Guess value must be between 1 and 100, got {}.", value);
10.         }
12.         Guess { value }
13.     }
15.     //有时被称为 getter，目的就是返回对应字段的数据
16.     pub fn value(&self) -> i32 {
17.         self.value
18.     }
19. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！