程序在运行的过程中，总是会不可避免地产生错误，而如何优雅地解决错误，也是语言的设计哲学之一。那么现有的主流语言是怎么处理错误的呢？比如调用一个函数，如果函数执行的时候出错了，那么该怎么处理呢。
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, &'static str> {
let ret: Result<i32, &'static str>;
// 如果 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, &'static str> {
// 外部的某个函数
Ok(666)
}
fn call1() -> Result<f64, &'static str> {
// 我们要调用 external_some_func
match external_some_func() {
// 类型转化在 Rust 里面通过 as 关键字
Ok(i) => Ok((i + 1) as f64),
Err(error) => Err(error)
}
}
// 但是上面这种调用方式有点繁琐
// 我们还可以使用问号表达式
fn call2() -> Result<f64, &'static str> {
// 注：使用问号表达式有一个前提
// 调用方和被调用方的返回值都要是 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, &'static str> {
// 外部的某个函数
Err("函数执行出错")
}
fn call1() -> Result<f64, &'static str> {
match external_some_func() {
Ok(i) => Ok((i + 1) as f64),
Err(error) => Err(error)
}
}
fn call2() -> Result<f64, &'static str> {
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<FileNotFoundError> 和 From<IndexError>
impl From<FileNotFoundError> for MyError {
fn from(error: FileNotFoundError) -> MyError {
MyError::Error1(error)
}
}
impl From<IndexError> for 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 的错误处理，相比其它语言来说，确实难理解了一些。另外从该系列的开始到现在，我们介绍的都属于基础内容，而且有些地方介绍的还不够详细，后续我们会将这些内容以更深入的方式做一个补充。
