程序在运行的过程中，总是会不可避免地产生错误，而如何优雅地解决错误，也是语言的设计哲学之一。那么现有的主流语言是怎么处理错误的呢?比如调用一个函数，如果函数执行的时候出错了，那么该怎么处理呢。

　　C 语言

　　C 是一门古老的语言，通常会以指针作为参数，在函数内部进行解引用，修改指针指向的值。然后用 1 和 0 代表返回值，如果返回 1，则表示修改成功;返回 0，表示修改失败。

　　但这种做法有一个缺陷，就是修改失败时，无法将原因记录下来。

　　C++ 和 Python

　　引入了 Exception，通过 try catch 可以将异常捕获，相比 C 进步了一些。但它的缺陷是我们不知道被调用方会抛出什么异常。

　　Java

　　引入了 checked exception，方法的所有者可以声明自己会抛出什么异常，然后调用者对异常进行处理。在 Java 程序启动时，抛出大量异常都是司空见惯的事情，并在相应的调用堆栈中将信息完整地记录下来。至此，Java 的异常不再是异常，而是一种很普遍的结构，从良性到灾难性都有所使用，异常的严重性由调用者来决定。

　　而像 Go、Rust 这样的新兴语言，则采用了与之不同的方式。它们没有像传统的高级语言一样引入 try cache，因为设计者认为这会把控制流搞得非常乱。在 Go 和 Rust 里面，错误是通过返回值体现的。

　　比如打开一个文件，如果文件不存在，像 Python 程序就会直接报错。但 Go 不一样，Go 在打开文件的时候会同时返回一个文件句柄和 error，如果文件成功打开，那么 error 就是空;如果文件打开失败，那么 error 就是错误原因。

　　所以对于 Go 而言，在可能出错的时候，程序会同时返回 value 和 error。如果你要使用 value，那么必须先对 error 进行判断。

　　错误和异常

　　我们上面提到了错误(Error)和异常(Exception)，有很多人分不清这两者的区别，我们来解释一下。

　　在 Python 里面很少会对错误和异常进行区分，甚至将它们视做同一种概念。但在 Go 和 Rust 里面，错误和异常是完全不同的，异常要比错误严重得多。

　　当出现错误时，开发者是有能力解决的，比如文件不存在。这时候程序并不会有异常产生，而是正常执行，只是作为返回值的 error 不为空，开发者要基于 error 进行下一步处理。

　　但如果出现了异常，那么一定是代码写错了，开发者无法处理了。比如索引越界，程序会直接 panic 掉，所以在 Rust 里面异常又叫做不可恢复的错误。

　　不可恢复的错误

　　如果在 Rust 里面出现了异常，也就是不可恢复的错误，那么就表示开发者希望程序立刻中止掉，不要再执行下去了。

　　而不可恢复的错误，除了程序在运行过程中因为某些原因自然产生之外，也可以手动引发。

　　fn main() {

　　println!("程序开始执行");

　　// 在 Go 里面引发异常通过 panic 函数

　　// Rust 则是通过 panic! 宏，还是挺相似的

　　panic!("发生了不可恢复的错误");

　　println!("程序不会执行到这里");

　　}

　　注意 panic! 和 println! 的参数一致的，都支持字符串格式化输出。下面看一下输出结果：

　　如果将环境变量 RUST_BACKTRACE 设置为 1，还可以显示调用栈。

　　然后除了 panic! 之外，assert 系列的宏也可以生成不可恢复的错误。

　　fn main() {

　　// 如果 assert! 里面的布尔值为真，无事发生

　　// 如果为假，那么程序会 panic 掉

　　assert!(1 == 2);

　　// assert!(1 == 2) 还可以写成

　　assert_eq!(1, 2);

　　// 除了 assert_eq! 外，还有 assert_ne!

　　assert_ne!(1, 2);

　　// 不过最常用的还是 assert!

　　}

　　还有一个宏叫 unimplemented!，当我们的代码还没有开发完毕时，为了在别人调用的时候能够提示调用者，便可以使用这个宏。

　　fn get_data() {

　　unimplemented!("还没开发完毕，by {}", "古明地觉");

　　}

　　fn main() {

　　get_data()

　　}

　　它和 Python 里的 raise NotImplementedError 是比较相似的。

　　最后在 Rust 里面还有一个常用的宏，用于表示程序不可能执行到某个地方。

　　fn divide_by_3(n: u32) -> u32 {

　　// 找到可以满足 3 * i 大于 n 的最小整数 i

　　for i in 0 .. {

　　if 3 * i > n {

　　return i;

　　}

　　}

　　// 显然程序不可能执行到这里

　　// 因为 for 循环是无限进行的，最终一定会 return

　　// 但 Rust 在编译时，从语法上是判断不出来的

　　// 它只知道这个函数目前不完整，因为如果 for 循环结束，

　　// 那么返回值就不符合 u32 类型了，尽管我们知道 for 循环不可能结束

　　// 为此我们可以随便 return 一个 u32，并写上注释

　　// "此处是为了保证函数签名合法，但程序不会执行到这里"

　　// 而更专业的做法是使用一个宏

　　unreachable!("程序不可能执行到这里");

　　}

　　如果程序真的执行到了该宏所在的地方，那么同样会触发一个不可恢复的错误。

　　以上就是 Rust 里面的几个用于创建不可恢复的错误的几个宏。

　　可恢复的错误

　　说完了不可恢复的错误，再来看看可恢复的错误，一般称之为错误。在 Go 里面错误是通过多返回值实现的，如果程序可能出现错误，那么会多返回一个 error，然后根据 error 是否为空来判断究竟有没有产生错误。所以开发者必须先对 error 进行处理，然后才可以执行下一步，不应该对 error 进行假设。

　　而 Rust 的错误机制和 Go 类似，只不过是通过枚举实现的，该枚举叫 Result，我们看一下它的定义。

　　pub enum Result<t, e=""> {

　　Ok(T),

　　Err(E),

　　}

　　如果将定义简化一下，那么就是这个样子。可以看到它就是一个简单的枚举，并且带有两个泛型。我们之前也介绍过一个枚举叫 Option，用来处理空值的，内部有两个成员，分别是 Some 和 None。

　　然后枚举 Result 和 Option 一样，它和内部的成员都是可以直接拿来用的，我们实际举个例子演示一下吧。

　　// 计算两个 i32 的商

　　fn divide(a: i32, b: i32) -> Result<i32, str="" &?static=""> {

　　let ret: Result<i32, str="" &?static="">;

　　// 如果 b != 0，返回 Ok(a / b)

　　if b != 0 {

　　ret = Ok(a / b);

　　} else {

　　// 否则返回除零错误

　　ret = Err("ZeroDivisionError: division by zero")

　　}

　　return ret;

　　}

　　fn main() {

　　let a = divide(100, 20);

　　println!("a = {:?}", a);

　　let b = divide(100, 0);

　　println!("b = {:?}", b);

　　/*

　　a = Ok(5)

　　b = Err("ZeroDivisionError: division by zero")

　　*/

　　}

　　打印结果如我们所料，但 Rust 和 Go 一样，都要求我们提前对 error 进行处理，并且 Rust 比 Go 更加严格。对于 Go 而言，在没有发生错误的时候，即使我们不对 error 做处理(不推荐)，也是没问题的。而 Rust 不管会不会发生错误，都要求对 error 进行处理。

　　因为 Rust 返回的是枚举，比如上面代码中的 a 是一个 Ok(i32)，即便没有发生错误，这个 a 也不能直接用，必须使用 match 表达式处理一下。

　　fn main() {

　　// 将返回值和 5 相加，由于 a 是 Ok(i32)

　　// 显然它不能直接和 i32 相加

　　let a = divide(100, 20);

　　match a {

　　Ok(i) => println!("a + 5 = {}", i + 5),

　　Err(error) => println!("出错啦: {}", error),

　　}

　　let b = divide(100, 0);

　　match b {

　　Ok(i) => println!("b + 5 = {}", i + 5),

　　Err(error) => println!("出错啦: {}", error),

　　}

　　/*

　　a + 5 = 10

　　出错啦: ZeroDivisionError: division by zero

　　*/

　　}

　　虽然这种编码方式会让人感到有点麻烦，但它杜绝了出现运行时错误的可能。相比运行时报错，我们宁可在编译阶段多费些功夫。

　　自定义错误和问号表达式

　　我们说 Rust 为了避免控制流混乱，并没有引入 try cache 语句。但 try cache 也有它的好处，就是可以完整地记录堆栈信息，从错误的根因到出错的地方，都能完整地记录下来，举个 Python 的例子：

　　程序报错了，根因是调用了函数 f，而出错的地方是在第 10 行，我们手动 raise 了一个异常。可以看到程序将整个错误的链路全部记录下来了，只要从根因开始一层层往下定位，就能找到错误原因。

　　而对于 Go 和 Rust 来说就不方便了，特别是 Go，如果每返回一个 error，就打印一次，那么会将 error 打的乱七八糟的。所以我们更倾向于错误能够在上下文当中传递，对于 Rust 而言，我们可以通过问号表达式来实现这一点。

　　fn external_some_func() -> Result<u32, str="" &?static=""> {

　　// 外部的某个函数

　　Ok(666)

　　}

　　fn call1() -> Result<f64, str="" &?static=""> {

　　// 我们要调用 external_some_func

　　match external_some_func() {

　　// 类型转化在 Rust 里面通过 as 关键字

　　Ok(i) => Ok((i + 1) as f64),

　　Err(error) => Err(error)

　　}

　　}

　　// 但是上面这种调用方式有点繁琐

　　// 我们还可以使用问号表达式

　　fn call2() -> Result<f64, str="" &?static=""> {

　　// 注：使用问号表达式有一个前提

　　// 调用方和被调用方的返回值都要是 Result 枚举类型

　　// 并且它们的错误类型要相同，比如这里都是 &'static str

　　let ret = external_some_func()?;

　　Ok((ret + 1) as f64)

　　}

　　fn main() {

　　println!("{:?}", call1()); // Ok(667.0)

　　println!("{:?}", call2()); // Ok(667.0)

　　}

　　里面的 call1 和 call2 是等价的，如果在 call2 里面函数调用出错了，那么会自动将错误返回。并且注意 call2 里面的 ret，它是 u32，不是 Ok(u32)。因为函数调用出错会直接返回，不出错则会将 Ok 里面的 u32 取出来赋值给 ret。

　　然后我们说如果 external_some_func 函数执行出错了，那么 call2 就直接将错误返回了，程序不会再往下执行。所以这也侧面要求，call2 和 external_some_func 的返回值类型都是 Result，并且里面的错误类型也要一样，否则函数签名是不合法的。

　　fn external_some_func() -> Result<u32, str="" &?static=""> {

　　// 外部的某个函数

　　Err("函数执行出错")

　　}

　　fn call1() -> Result<f64, str="" &?static=""> {

　　match external_some_func() {

　　Ok(i) => Ok((i + 1) as f64),

　　Err(error) => Err(error)

　　}

　　}

　　fn call2() -> Result<f64, str="" &?static=""> {

　　let ret = external_some_func()?;

　　Ok((ret + 1) as f64)

　　}

　　fn main() {

　　println!("{:?}", call1()); // Err("函数执行出错")

　　println!("{:?}", call2()); // Err("函数执行出错")

　　}

　　此时错误就自动地在上下文当中传递了，并且还更简洁，只需要在函数调用后面加一个问号即可。

　　再来考虑一种更复杂的情况，我们在调用函数的时候可能会调用多个函数，而这多个函数的错误类型不一样该怎么办呢?

　　struct FileNotFoundError {

　　err: String,

　　filename: String,

　　}

　　struct IndexError {

　　err: &'static str,

　　index: u32,

　　}

　　fn external_some_func1() -> Result<u32, filenotfounderror=""> {

　　Err(FileNotFoundError {

　　err: String::from("文件不存在"),

　　filename: String::from("main.py"),

　　})

　　}

　　fn external_some_func2() -> Result<i32, indexerror=""> {

　　Err(IndexError {

　　err: "索引越界了",

　　index: 9,

　　})

　　}

　　很多时候，错误并不是一个简单的字符串，因为那样能携带的信息太少。基本上都是一个结构体，文字格式的错误信息只是里面的字段之一，而其它字段则负责描述更加详细的上下文信息。

　　我们上面有两个函数，是一会儿我们要调用的，但问题是它们返回的错误类型不同，也就是 Result<t, e=""> 里面的 E 不同。而如果是这种情况的话，问号表达式就会失效，那么我们应该怎么做呢?

　　// 其它代码不变

　　#[derive(Debug)]

　　enum MyError {

　　Error1(FileNotFoundError),

　　Error2(IndexError)

　　}

　　// 为 MyError 实现 From trait

　　// 分别是 From和 From

　　impl Fromfor MyError {

　　fn from(error: FileNotFoundError) -> MyError {

　　MyError::Error1(error)

　　}

　　}

　　impl Fromfor MyError {

　　fn from(error: IndexError) -> MyError {

　　MyError::Error2(error)

　　}

　　}

　　fn call1() -> Result<i32, myerror="">{

　　// 调用的两个函数、和当前函数返回的错误类型都不相同

　　// 但是当前函数是合法的，因为 MyError 实现了 From trait

　　// 当错误类型是 FileNotFoundError 或 IndexError 时

　　// 它们会调用 MyError 实现的 from 方法

　　// 然后将错误统一转换为 MyError 类型

　　let x = external_some_func1()?;

　　let y = external_some_func2()?;

　　Ok(x as i32 + y)

　　}

　　fn call2() -> Result<i32, myerror="">{

　　let y = external_some_func2()?;

　　let x = external_some_func1()?;

　　Ok(x as i32 + y)

　　}

　　fn main() {

　　println!("{:?}", call1());

　　/*

　　Err(Error1(FileNotFoundError { err: "文件不存在", filename: "main.py" }))

　　*/

　　println!("{:?}", call2());

　　/*

　　Err(Error2(IndexError { err: "索引越界了", index: 9 }))

　　*/

　　}

　　如果调用的多个函数返回的错误类型相同，那么只需要保证调用方也返回相同的错误类型，即可使用问号表达式。但如果调用的多个函数返回的错误类型不同，那么这个时候调用方就必须使用一个新的错误类型，其数据结构通常为枚举。

　　而枚举里的成员要包含所有可能发生的错误类型，比如这里的FileNotFoundError和IndexError。然后为枚举实现 From trait，该 trait 带了一个泛型，并且内部定义了一个 from 方法。

　　我们在实现之后，当出现 FileNotFoundError 和 IndexError 的时候，就会调用 from 方法，转成调用方的 MyError 类型，然后返回。

　　因此这就是 Rust 处理错误的方式，可能有一些难理解，需要私下多琢磨琢磨。最后再补充一点，我们知道 main 函数应该返回一个空元组，但除了空元组之外，它也可以返回一个 Result。

　　fn main() -> Result<(), MyError> {

　　// 如果 call1() 的后面没有加问号

　　// 那么在调用没有出错的时候，返回的就是 Ok(...)

　　// 调用出错的时候，返回的就是 Err(...)

　　// 但不管哪一种，都是 Result<t, e=""> 类型

　　println!("{:?}", call1());

　　// 如果加了 ? 那么就不一样了

　　// 在调用没出错的时候，会直接将 Ok(...) 里面的值取出来

　　// 调用出错的时候，当前函数会中止运行，

　　// 并将被调用方(这里是 call2)的错误作为调用方(这里是 main)的返回值返回

　　// 此时通过问号表达式，就实现了错误在上下文当中传递

　　// 所以这也要求被调用方返回的错误类型要和调用方相同

　　println!("{:?}", call2()?);

　　// 为了使函数签名合法，这里要返回一个值，直接返回 Ok(()) 即可

　　// 但上面的 call2()? 是会报错的，所以它下面的代码都不会执行

　　Ok(())

　　}

　　我们执行一下看看输出：

　　由于 main 函数已经是最顶层的调用方了，所以出错的时候，直接将错误抛出来了。

　　以上就是 Rust 的错误处理，相比其它语言来说，确实难理解了一些。另外从该系列的开始到现在，我们介绍的都属于基础内容，而且有些地方介绍的还不够详细，后续我们会将这些内容以更深入的方式做一个补充。