錯誤是軟件中不可避免的，所以 Rust 有一些處理出錯情況的特性。在許多情況下，Rust 要求你承認錯誤的可能性，并在你的代碼編譯前采取一些行動。這一要求使你的程序更加健壯，因為它可以確保你在將代碼部署到生產環境之前就能發現錯誤并進行適當的處理。

Rust中的錯誤可分為可 恢復錯誤 (recoverable)和 不可恢復錯誤 (unrecoverable)

可恢復錯誤代表一種可以恢復的情況下失敗，可以向用戶報告問題并重試操作，例如未找到文件；

不可恢復錯誤代表一種不可處理的狀態，會導致程序 崩2 ，例如嘗試訪問超過數組結尾的位置；

對比其他編程語言的錯誤處理:
1. Java語言采用了異常機制的方式來處理，并沒有明確區分可恢復錯誤和不可恢復錯誤。
(ps: 雖然Java的異常給出了Throwable, Error, Exception, RuntimeException的
繼承關系體系，異常分為checked exception和uncheced exceppion，但在異常傳播上
采用的是通過棧回溯的方式一層層傳遞，直到出現捕獲異常的地方。) Java語言這種異常
處理方式的優點是簡化了錯誤處理流程，但在運行時開銷比使用返回值返回錯誤信息的方式要大很多。
2. Go語言是明確區分可恢復錯誤(error)和不可恢復錯誤(panic)的。Go對可恢復錯誤
采用了以函數返回錯誤值的形式，在函數返回時額外返回一個錯誤對象(error)，這種方式的優點
是錯誤處理的運行時開銷小，缺點是返回的錯誤必須處理或者顯式傳播返回給上級調用，
因此一個Go程序代碼中會有大量的if err!= nil {return err;}。

Rust中沒有異常，對于可恢復錯誤使用了類型Result，即函數返回的錯誤信息通過類型系統描述。對于在程序遇到不可恢復的錯誤時panic!時停止執行

1. Result和可恢復錯誤

Result是一個枚舉類型，其定義如下:

#[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

Result枚舉有兩個成員，Ok和Err。T和E是泛型參數，T代表成功返回的Ok成員中的數據類型。E代表失敗返回的Err成員中的錯誤的類型。有了這兩個泛型參數，可以將Result枚舉作為函數的返回值，用于各種場景下的可恢復錯誤的處理，當函數成功時返回Ok(T)，失敗時返回Err(E)。

Result的定義上面有一個must_use的標注，rust的編譯器會對must_use標注的類型做特殊處理，如果該類型對應的值沒有被顯式使用，則就會有一個警告。例如下面的代碼。

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


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

代碼在調用foo函數時，忽略了返回值Result，因為Result上有must_use標注，所以Rust的編譯器在編譯時會報一個警告:

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:

#[stable(feature = "rust1", since = "1.0.0")]
pub type Result

從io::Result的定義可以看出，io::Result實際上是result::Result的別名。 io::Result中的Err成員類型是io::Error。

io::Error是一個結構體，它由一個kind()方法簽名是pub fn kind(&self) -> ErrorKind，返回描述錯誤原因枚舉ErrorKind。

ErrorKind的成員是各種io錯誤原因，比如NotFound, PermissionDenied…

因此如果函數返回io::Result，失敗時返回的是io::Error時，就可以調用kind方法，進一步匹配不同的錯誤原因進行不同處理。

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類型定義了很多輔助方法來處理各種情況。除了unwrap_or_else外，還有:

• unwrap方法: 如果Result的值是成員Ok，unwrap就返回Ok的值；如果Result的值是成員Err，unwrap就會調用panic!
• expect方法: 與unwrap的使用方式一樣，允許我們傳參指定panic!的信息

1.2 使用?操作符傳播錯誤

經常在編寫一個函數實現時會調用另一個返回Result的函數，除了在這個函數中處理錯誤之外，還可以選擇將錯誤傳播到上游調用者，這就是傳播錯誤。

rust還提供了強大的?操作符，如果我們只想要傳播錯誤，而不想直接處理，可以使用?操作符。

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)
}

代碼中第6行的?操作符會被展開成類似下面的代碼:

match result {
    Ok(v) => v,
    Err(e) => Err(e.into())
}
```Result 值之后的 ? 作用為與 match 表達式有著完全相同的工作方式。如果 Result 的值是 Ok，這個表達式將會返回 Ok 中的值而程序將繼續執行。如果值是 Err，Err 中的值將作為整個函數的返回值，就好像使用了 return 關鍵字一樣，這樣錯誤值就被傳播給了調用者。

match 表達式與 ? 運算符所做的有一點不同：? 運算符所使用的錯誤值被傳遞給了 from 函數，它定義于標準庫的 From trait 中，其用來將錯誤從一種類型轉換為另一種類型。當 ? 運算符調用 from 函數時，收到的錯誤類型被轉換為由當前函數返回類型所指定的錯誤類型。

## 2. panic! 和不可恢復錯誤

突然有一天，代碼出問題了，程序崩潰，對于這種情況，Rust提供了一個panic!宏，當執行這個宏時，程序會打印出一個錯誤信息，展開并清理棧數據，然后接著退出。出現這種情況的場景通常是檢測到一些類型的 bug，Rust程序員可以讓 Rust 在 panic 發生時打印調用堆棧（call stack）以便于定位 panic 的原因。

在實踐中有兩種方法造成 panic：

* 執行會造成代碼 panic 的操作，比如訪問超過數組結尾的內容
* 顯式調用 panic! 宏，比如`panic!("crash and burn");`。

panic!表示不可恢復的錯誤，希望程序馬上終止運行并得到崩潰信息。

rust標準庫還提供了`catch_unwind()`，可以把panic的調用棧回溯到catch_unwind的時候。

use std::panic;

fn main() {

let result = panic::catch_unwind(|| {

panic!("crash");

});

if result.is_err() {

println!("panic reover: {:#?}", result);

}

println!("exit ok!");

}

代碼運行結果如下:

thread 'main' panicked at 'crash', src/main.rs:4:9

note: run with RUST_BACKTRACE=1 environment variable to display

a backtracepanic reover: Err(

Any { .. },

)

exit ok!

### 2.1 使用 `panic!` 的 backtrace

可以使用 `RUST_BACKTRACE=1 cargo run` 來得到一個 backtrace，backtrace 是一個執行到目前位置所有被調用的函數的列表。Rust 的 backtrace 跟其他語言中的一樣：閱讀 backtrace 的關鍵是從頭開始讀直到發現你編寫的文件。這就是問題的發源地。這一行往上是你的代碼所調用的代碼；往下則是調用你的代碼的代碼。這些行可能包含核心 Rust 代碼，標準庫代碼或用到的 crate 代碼。

// src/main.rs

fn main() {

let v = vec![1, 2, 3];

v[99];

}

$ RUST_BACKTRACE=1 cargo run

thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5

stack backtrace:

0: rust_begin_unwind at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/std/src/panicking.rs:584:5

1: core::panicking::panic_fmt at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:142:14

2: core::panicking::panic_bounds_check at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:84:5

3: >::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:242:10

4: core::slice::index:: for [T]>::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:18:9

5: [alloc::vec::Vec as core::ops::index::Index*>::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/alloc/src/vec/mod.rs:2591:9

6: panic::main at ./src/main.rs:4:5

7: core::ops::function::FnOnce::call_once at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/ops/function.rs:248:5

note: Some details are omitted, run with RUST_BACKTRACE=full for a verbose backtrace.*](alloc::vec::Vec%3CT,A)

[**

## 總結

Rust 的錯誤處理功能被設計為幫助你編寫更加健壯的代碼。`panic!` 宏代表一個程序**無法處理**的狀態，并停止執行而不是使用無效或不正確的值繼續處理。Rust 類型系統的 `Result` 枚舉代表操作可能會在一種**可以恢復**的情況下失敗，可以使用 `Result` 來告訴代碼調用者他需要處理潛在的成功或失敗。在適當的場景使用 `panic!` 和 `Result` 將會使你的代碼在面對不可避免的錯誤時顯得更加可靠。

* 可恢復錯誤：想向用戶報告問題并**重試**操作，Result處理；
* 不可恢復錯誤：導致程序**崩潰的**panic，catch_unwind() 棧回溯；
* match匹配： 處理返回值`Result`，**匹配**出不同錯誤的原因；
* ？運算符： **傳播錯誤** ，將錯誤從一種類型轉換為另一種類型，返回給調用者；

**](alloc::vec::Vec%3CT,A)