今天开始学习rust中错误处理的内容。

Rust中的错误可分为 可恢复错误(recoverable)不可恢复错误(unrecoverable) 两个类别。

  • 可恢复错误通常代表向用户报告错误和重试操作是合理的情况,例如未找到文件
  • 不可恢复错误会导致程序崩溃,例如尝试访问超过数组结尾的位置

对比其他编程语言的错误处理:

  • Java语言采用了异常机制的方式来处理,并没有明确区分可恢复错误和不可恢复错误。(ps: 虽然Java的异常给出了Throwable, Error, Exception, RuntimeException的继承关系体系,异常分为checked exception和uncheced exceppion,但在异常传播上采用的是通过栈回溯的方式一层层传递,直到出现捕获异常的地方。) Java语言这种异常处理方式的优点是简化了错误处理流程,但在运行时开销比使用返回值返回错误信息的方式要大很多。
  • Go语言是明确区分可恢复错误(error)和不可恢复错误(panic)的。Go对可恢复错误采用了以函数返回错误值的形式,在函数返回时额外返回一个错误对象(error),这种方式的优点是错误处理的运行时开销小,缺点是返回的错误必须处理或者显式传播返回给上级调用,因此一个Go程序代码中会有大量的if err!= nil {return err;}

Rust中没有异常,对于可恢复错误使用了类型Result<T, E>,即函数返回的错误信息通过类型系统描述。对于不可恢复错误会panic!

1. Result<T, E>和可恢复错误

Result<T, E>在rust中时一个枚举类型,其定义如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
#[must_use = "this `Result` may be an `Err` variant, which should be handled"]
#[rustc_diagnostic_item = "result_type"]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum Result<T, E> {
    /// Contains the success value
    #[lang = "Ok"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    #[lang = "Err"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
}

Result<T, E>枚举有两个成员,OkErrTE是泛型参数,T代表成功返回的Ok成员中的数据类型。E代表失败返回的Err成员中的错误的类型。 有了这两个泛型参数,可以将Result枚举作为函数的返回值,用于各种场景下的可恢复错误的处理,当函数成功时返回Ok(T),失败时返回Err(E)

我们注意到Result的定义上面有一个must_use的标注,rust的编译器会对must_use标注的类型做特殊处理,如果该类型对应的值没有被显式使用,则就会有一个警告。 例如下面的代码。

例1:

1
2
3
4
5
6
7
8
9

fn foo() -> Result<(), String> {
    Ok(())
}

fn main() {
    foo(); // unused `std::result::Result` that must be used

}

例1的代码在调用foo函数时,忽略了返回值Result,因为Result上有must_use标注,所以Rust的编译器在编译时会报一个警告:

1
2
3
4
5
6
7
8
warning: unused `Result` that must be used
 --> src/main.rs:7:5
  |
7 |     foo(); // unused `std::result::Result` that must be used
  |     ^^^^^^
  |
  = note: `#[warn(unused_must_use)]` on by default
  = note: this `Result` may be an `Err` variant, which should be handled

1.1 匹配不同的错误原因

在处理错误时,很多时候需要针对不同的错误原因进行不同的处理。 下面来学习一下rust标准库中的std::io module中是如何设计错误处理的。

std::io中定义了一个std::io::Result:

1
2
#[stable(feature = "rust1", since = "1.0.0")]
pub type Result<T> = result::Result<T, Error>;

io::Result的定义可以看出,io::Result实际上时result::Result<T, Error>的别名。 io::Result中的Err成员类型是io::Error

io::Error是一个结构体,它由一个kind()方法签名是pub fn kind(&self) -> ErrorKind,返回描述错误原因枚举ErrorKind

ErrorKind枚举的成员是各种io错误原因,例如NotFound, PermissionDenied

因此如果函数返回io::Result,失败时返回的是io::Error时,就可以调用kind方法,进一步匹配不同的错误原因进行不同处理。

例2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt").unwrap_or_else(|err| {
        match err.kind() {
            ErrorKind::NotFound => File::create("hello.tx").unwrap_or_else(|error| {
                panic!("Problem creating the file: {:?}", error);
            }), // 匹配错误原因, 对于文件不存在的错误处理为创建文件
            other_error_kind => panic!("Problem opening the file: {:?}", other_error_kind)
        }
    });
    println!("{:?}", f);
}

例2中还用到了Result的unwrap_or_else方法,Result<T, E>类型定义了很多辅助方法来处理各种情况。 除了unwrap_or_else外,还有:

  • unwrap方法: 如果Result的值是成员Okunwrap就返回Ok的值;如果Result的值是成员Errunwrap就会调用panic!
  • expect方法: 与unwrap的使用方式一样,允许我们传参指定panic!的信息

1.2 使用?操作符传播错误

经常在编写一个函数实现时会调用另一个返回Result<T, E>的函数,除了在这个函数中处理错误之外,还可以选择将错误传播到上游调用者,这就是传播错误

rust还提供了强大的?操作符,如果我们只想要传播错误,而不想直接处理,可以使用?操作符。

例3:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
use std::io;
use std::io::Read;
use std::fs::File;

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

例3代码中第6行的?操作符会被展开成类似下面的代码:

1
2
3
4
match result {
    Ok(v) => v,
    Err(e) => Err(e.into())
}

对比一下Go语言里if err!= nil {return err;},在rust中传播错误是不是比较爽。

2. panic! 和不可恢复错误

rust提供了一个panic!宏,当执行这个宏时,程序会打印出一个错误信息,展开并清理栈数据,然后接着退出。 出现这种情况的场景通常是检测到一些类型的 bug,而且Rust程序员并不清楚该如何处理它时,对应的是不可恢复错误。

panic!表示不可恢复的错误,希望程序马上终止运行并得到崩溃信息。

可以在需要时在我们自己的代码中使用panic!,例如panic!("crash and burn");

rust标准库还提供了catch_unwind(),可以把panic的调用栈回溯到catch_unwind的时候,作用有点类似于Go语言中的recover

例4:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
use std::panic;
fn main() {
    let result = panic::catch_unwind(|| {
        panic!("crash");
    });
    if result.is_err() {
        println!("panic reover: {:#?}", result);
    }
    println!("exit ok!");
}

例4的代码运行结果如下:

1
2
3
4
5
6
thread 'main' panicked at 'crash', src/main.rs:4:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
panic reover: Err(
    Any { .. },
)
exit ok!

最后,需要注意catch_unwind的使用场景可对标go语言中的recover,不能到处滥用,因为rust的catch_unwind和go的recove一样,不是Java里的异常处理。

参考