Rust 编程语言将错误分为「不可恢复的错误」(unrecoverable error)和「可恢复的错误」(recoverable error),程序开发人员必须依照程序逻辑来自行决定应该要让程序使用哪种类型的错误。

简单来说,「不可恢复的错误」就好比使用超出数组索引范围的索引值来访问数组,但这样的数组用法连一次都不应该出现,否则就是程序有 Bug(臭虫)。「可恢复的错误」就好比要透过一个文件路径来读取一个文件,但这个文件并不存在,因为没有文件可读取,所以就以一个错误来代替,当程序判断到这个错误发生的时候,就知道也许要去改用其它的文件路径来读取,或是请用户再输入一次正确的文件路径。

大部分的编程语言并没有将错误明显区分为不可恢复或是可恢复,而是直接使用「例外」(exception)机制来统一处理。然而 Rust 编程语言并没有例外机制,我们在先前章节遇到的程序 panic,就是程序在运行的时候发生了不可恢复的错误,所以使用 panic 来显示错误消息并中止程序的运行。我们在先前的章节也有学到 Result 枚举,它就是用来处理可恢复的错误。

不可恢复的错误用 panic! 宏来处理

Rust 编程语言提供了 panic! 这个宏来印出错误消息,并解开(unwind)目前堆栈中的数据,然后中止程序的运行,换句话说就是能够让程序 panic。

以下程序,在 main 函数中直接使用 panic! 宏来使程序发生 panic:

fn main() {
    panic!("crash and burn");
}

运行结果如下图:

以 panic! 宏使程序发生 panic

从上图可以看到,程序运行的错误消息中会有发生 panic 的线程名称与我们传进 panic! 宏的文字 crash and burn,还有产生这个 panic 的源代码文件与行号。此外,也可以看到这个提示 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace,我们也试着加上这个环境变量设置来运行程序吧!运行结果如下图:

设置 RUST_BACKTRACE=1 显示的堆栈信息

在预设的情况下,当 Rust 程序发生 panic 时,会对那个时间点的堆栈数据进行「解开」的动作,如果环境变量 RUST_BACKTRACE 设为 1 的话,就会把这些堆栈数据透过标准错误(stderr)传出,用户就可以知道程序究竟是运行到什么后才发生这个 panic。

根据运行结果的提示,还可以将环境变量 RUST_BACKTRACE 设为 full,来查看更完整的消息。运行结果如下图:

RUST_BACKTRACE 设为 full 的完整消息

当然,我们也许会担心制作出来的 Rust 程序在交付给客户后会因为程序 panic 把所有堆栈中有关代码的详细数据都印出来,而使得程序很容易就能被逆向工程反推出源代码,因为即便使用 release 模式来编译程序,也还是会保留这个功能。程序运行结果如下图:

release 模式下仍会印出的堆栈数据

我们可以在 Rust 的程序项目的 Cargo.toml 设置档中,加入 [profile.release] 区块,并将 panic 设置项目的值设为 abort。如下:

[package]
name = "panic_test"
version = "0.1.0"
edition = "2021"

[profile.release]
panic = "abort"

[dependencies]

如此一来,之后使用 release 模式编译出来的程序发生 panic 时,就会直接中止程序的运行,而不会去「解开」堆栈空间的数据。但是还是会有一些堆栈数据,在设置环境变量 RUST_BACKTRACE 之后会被显示出来。

设置 panic = abort 后的运行结果

虽然这些堆栈数据跟我们写的代码无关,显示出来没什么大碍,但如果想要将其消去的话还是有办法的,那就是在 [profile.release] 区块中将 strip 设置项目的值设为 true,将编译出来的文件中不必要的标头和调试信息移除。如下:

[package]
name = "panic_test"
version = "0.1.0"
edition = "2021"

[profile.release]
panic = "abort"
strip = true

[dependencies]

程序运行结果如下图:

加上 strip = true 后的运行结果

如果要连使用 panic! 宏所产生出来的线程名称和产生 panic 的程序源代码位置都不要显示的话,要使用 std::panic 模块提供的 set_hook 函数来自订之后使用 panic! 宏时要运行的代码。举例来说:

use std::panic::set_hook;

fn main() {
    set_hook(Box::new(|panic_info| {
        eprintln!("{}", panic_info.payload().downcast_ref::<&str>().unwrap());
    }));

    panic!("crash and burn");
}

以上程序,使用 panic! 宏后,会去运行第 5 进程式,利用 eprintln! 宏把传入至 panic! 宏的错误消息文字给输出到标准错误(stderr)中。程序第 4 行到第 6 行,以我们现在的 Rust 编程语言功力还看不懂它,也没关系,现阶段如果有需要隐藏 panic! 宏所产生出来的线程名称和产生 panic 的程序源代码位置的话,就来这里拷贝粘贴这段代码吧!

隐藏线程名称与源代码位置的 panic 消息

可恢复的错误用 Result 枚举来处理

先前我们已经探讨过枚举的用法了,这里就不再多说。Rust 编程语言的标准函数库提供的许多函数和方法都会回传 Result 枚举的实体,或许我们没有办法把这些函数和方法都记下来,但也不用担心,如果函数或方法有回传值却没有去处理,编译器会出现警告消息。原本就应该要回传数据的函数或方法也会使用 Result 枚举来包裹,例如 std::fs 模块中 File 结构体提供的 open 函数,其可用来打开一个指定路径的文件。举例来说:

use std::fs::File;

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

以上程序,第 4 行会编译错误,因为 open 函数回传的值是 Result 枚举,而不是直接将 File 结构实体回传。可以将程序修改如下:

use std::fs::File;

fn main() {
    let f: File = match File::open("hello.txt") {
        Ok(file) => file,
        Err(error) => {
            panic!("There was a problem opening the file: {:?}", error);
        }
    };
}

以上程序利用 match 关键字来对 open 函数回传的值进行型样匹配,判断文件到底有没有打开成功。如果有成功,就用声明出来的 f 变量保存 File 结构实体;如果不成功,就让程序发生 panic。这里要注意的是,由于使用 panic! 宏之后,接下来的程序叙述都运行不到了,因此 Err(error) 这个 arm 就算没有让它回传一个 File 结构实体,程序也不会编译错误。

直接使用 Err(error) 来做型样匹配的话,不管是什么样的错误都会被匹配到。如果我们要将一些特定的错误抓出来处理,该怎么做呢?

举例来说,我们希望如果发生错误的原因是因为文件不存在,就去创建新文件出来;而如果是其它错误,就让程序发生 panic。程序如下:

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

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

    let f = match f {
        Ok(file) => file,
        Err(ref error) if error.kind() == ErrorKind::NotFound => match File::create("hello.txt") {
            Ok(fc) => fc,
            Err(e) => {
                panic!("Tried to create file but there was a problem: {:?}", e)
            },
        },
        Err(error) => {
            panic!("There was a problem opening the file: {:?}", error)
        },
    };
}

File 结构体的 open 函数所回传的 Result 枚举,其 Err 变体包裹的值为 std::io 模块下的 Error 结构体,这个 Error 结构的实体提供了一个 kind 方法,可以回传 std::io 的 ErrorKind 枚举的实体,可以用来判断这个 Error 结构实体的错误类型。以上程序第 9 行,我们利用「匹配守卫」增加了一个匹配条件,那就是判断 Error 结构实体的 kind 方法回传的枚举是否为 ErrorKind 枚举的 NotFound 变体。File 结构体的 create 函数可以在指定路径创建文件,它也会回传一个 Result 枚举实体,所以也可以使用 match 关键字来进行型样匹配。

再来回头看一下之前的程序:

use std::fs::File;

fn main() {
    let f: File = match File::open("hello.txt") {
        Ok(file) => file,
        Err(error) => {
            panic!("There was a problem opening the file: {:?}", error);
        }
    };
}

虽然 Result 枚举是用来处理可恢复的错误,但我们却不一定每次都会对它进行特别处理,取而代之的是让程序再产生不可恢复的错误,也就是让程序发生 panic。如果每次遇到不想处理的 Result 枚举,代码都要用以上的方式来撰写的话,好像就有点过于麻烦。还好 Rust 编程语言已经替 Result 枚举实作了不少有用的方法,例如以上这个程序,就可以用 unwrap 方法来简化,程序如下:

use std::fs::File;

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

这个 unwrap 方法,基本上就是去判断实体是 Ok 变体的实体还是 Err 变体的实体。如果是前者,就直接将 Ok 实体所包裹的值回传出来;如果是后者,就会用 panic! 宏并代入 Err 实体包裹的值,来使程序发生 panic。

另外,Result 枚举还有一个好用的 expect 方法,这个方法我们在一开始练习写猜数字程序时就有使用过了。程序如下:

use std::fs::File;

fn main() {
    let f = File::open("hello.txt").expect("Failed to open hello.txt");
}

unwrap 方法和 expect 方法的差别在于:unwrap 方法是将原本 Result 枚举所包裹的 Err 值作为程序 panic 的错误消息显示出来;而 expect 方法则是可以使用我们从参数传入的字符串来作为程序 panic 的错误消息。

如果我们正在将特定的逻辑功能以函数的方式实作,我们可以考虑把函数中遇到的错误以 Result 枚举来包裹回传,让调用这个函数的调用者(caller)自行去处理函数在运行过程中所遭遇的错误。举例来说:

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

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e)
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e)
    }
}

read_username_from_file 函数会打开 hello.txt 文件,如果文件打开成功,就会去读文件保存的字符串数据,如果字符串数据读取成功,就会回传这笔字符串数据。在 read_username_from_file 函数运行过程中所遭遇到的可恢复错误,都会直接以 Result 枚举包裹并回传出来。注意程序第 10 行,我们直接在 match 关键字的 arm 中使用 return 关键字,看起来似乎有点诡异。

先前虽然提到过,使用大括号 {} 组成的程序叙述区块,最后一行的程序叙述如果不加上分号,就会将值回传出去,且如果只有一行叙述,可以将大括号省略。那如果我们在这种程序叙述区块内使用 return 关键字呢?举例来说:

fn main() {
    let x = 5;
    let y = 6;
    let z = {
        x + y
    };
}

以上程序,再将第 5 行的 x + y 改为 return x + y,如下:

fn main() {
    let x = 5;
    let y = 6;
    let z = {
        return x + y
    };
}

程序修改之后,第 5 行会造成编译错误,因为 main 函数不能有回传值!即便把第 5 行加上分号,改为 return x + y;,重新编译也还是一样的结果。虽然 return 关键字是写在这样一个独立的程序区块内,但是它也算是函数主体代码的一部份,因此 return 关键字是可以使用的,但会直接作用在函数上,而不是目前这个程序区块。其实只要这样想:if 关键字所组成的程序区块可以使用 return 关键字,就能理解了。由此可知,作用在循环的 break、continue 关键字也是可以写在独立的程序区块内。

也就是说,Err(e) => return Err(e) 这条 arm,会让 read_username_from_file 函数回传 Err(e),而不是将 Err(e) 回传给第二次声明出来的 f 变量使用。

因为在实作函数时,「直接将 Result 枚举的 Err 实体所包裹的值回传出去」是很常见的作法,如果一直要用 match 关键字去做型样匹配实在很麻烦。还好,Rust 编程语言提供了一个超方便的语法糖可以解决这个问题,那就是问号 ?。程序如下:

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

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = f?;

    let mut s = String::new();


    f.read_to_string(&mut s)?;

    Ok(s)
}

在 Result 枚举的实体后加上问号,就可以判断其是 Ok 还是 Err 变体的实体。如果是前者,就会回传 Ok 实体所包裹的值;如果是后者,就会直接让函数回传 Err 实体。也由于问号语法会直接让函数回传 Result 枚举的实体,虽然只会有 Err 变体所产生出来的实体,但是在定义函数的回传值类型时,还是要把 Result 枚举的类型给明确地写上,否则就无法在这个函数内使用问号语法。

总结

Rust 编程语言可以使用 panic! 宏来处理不可恢复的错误,使用 Result 枚举来处理可恢复的错误。程序开发人员虽然必须依照程序逻辑来自行决定应该要让程序使用哪种类型的错误,但整体来说,简单的程序,例如范例程序、原型构想,可以直接使用 panic! 宏来处理所有错误,这样比较能够凸显程序的重点,也可以节省不少代码的撰写时间。此外,测试程序也可以直接使用 panic! 宏来处理所有错误,测试的最终目的是要让程序可以毫无错误地通过我们预想的每个测试案例,如果在测试过程中就发现错误,应该就要停止测试该案例,并同时输出错误消息,如此一来,程序开发人员就可以去对应的地方修改程序,解决问题。

还有就是我们所使用的函数或是方法虽然会回传 Result 枚举的实体,但也并不代表在程序运行阶段调用它时,就一定有可能会发生错误而回传 Err 实体。例如将字符串定数 123 使用 parse 方法转成数值类型,虽然 parse 方法还是会回传 Result 枚举的实体,但我们知道这样的程序逻辑是一定不会有错误的,此时就可以直接使用 Result 枚举的实体所提供的 expect 方法,甚至是直接用 unwrap 方法,不去自行处理那些不可能会发生的可恢复错误。

在下一章节中,我们会学习如何使用泛型和特性,来让我们的 Rust 程序变得更加灵活!

下一章:泛型、特性和生命周期。