Rust入坑指南：亡羊補牢

如果你已經開始學習Rust，相信你已經體會過Rust編譯器的強大。它可以幫助你避免程序中的大部分錯誤，但是編譯器也不是萬能的，如果程序寫的不恰當，還是會發生錯誤，讓程序崩潰。所以今天我們就來聊一聊Rust中如何處理程序錯誤，也就是所謂的“亡羊補牢”。

基礎概念

在編程中遇到的非正常情況通常可以分爲三類：失敗、錯誤、異常。

Rust中用兩種方式來消除失敗：強大的類型系統和斷言。

對於類型系統，熟悉Java的同學應該比較清楚。例如我們給一個接收參數爲int的函數傳入了字符串類型的變量。這是由編譯器幫我們處理的。

關於斷言，Rust支持6種斷言。分別是：

assert!
assert_eq!
assert_ne!
debug_assert!
debug_assert_eq!
debug_assert_ne!

從名稱我們就可以看出來這6種斷言，可以分爲兩大類，帶debug的和不帶debug的，它們的區別就是assert開頭的在調試模式和發佈模式下都可以使用，而debug開頭的只可以在調試模式下使用。再來解釋每個大類下的三種斷言，assert!是用於斷言布爾表達式是否爲true，assert_eq!用於斷言兩個表達式是否相等，assert_ne!用於斷言兩個表達式是否不相等。當不符合條件時，斷言會引發線程恐慌（panic!）。

Rust處理異常的方法有4種：Option、Result<T, E>、線程恐慌（Panic）、程序終止（Abort）。接下來我們對這些方法進行詳細介紹。

Option

Option我們在Rust入坑指南：千人千構一文中我們進行過一些介紹，它是一種枚舉類型，主要包括兩種值：Some(T)和None，Rust也是靠它來避免空指針異常的。

在前文中，我們並沒有詳細介紹如何從Option中提取出T，其實最基本的，可以用match來提取。而我也在前文中給你提供了官方文檔的鏈接，不知道你有沒有看。如果還沒來得及看也沒有關係，我把我看到的一些方法分享給你。

這裏介紹兩種方法，一種是expect，另一種是unwrap系列的方法。我們通過一個例子來感受一下。

fn main() {
    let a = Some("a");
    let b: Option<&str> = None;
    assert_eq!(a.expect("a is none"), "a");
    assert_eq!(b.expect("b is none"), "b is none");  //匹配到None會引起線程恐慌，打印的錯誤是expect的參數信息

    assert_eq!(a.unwrap(), "a");   //如果a是None，則會引起線程恐慌
    assert_eq!(b.unwrap_or("b"), "b"); //匹配到None時返回指定值
    let k = 10;
    assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);// 與unwrap_or類似，只不過參數是FnOnce() -> T
    assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
}

這是從Option中提取值的方法，有時我們會覺得每次處理Option都需要先提取，然後再做相應計算這樣的操作比較麻煩，那麼有沒有更加高效的操作呢？答案是肯定的，我從文檔中找到了map和and_then這兩種方法。

其中map方法和unwrap一樣，也是一系列方法，包括map、map_or和map_or_else。map會執行參數中閉包的規則，然後將結果再封爲Option並返回。

fn main() {
    let some_str = Some("Hello!");
    let some_str_len = some_str.map(|s| s.len());
    assert_eq!(some_str_len, Some(6));
}

但是，如果參數本身返回的結果就是Option的話，處理起來就比較麻煩，因爲每執行一次map都會多封裝一層，最後的結果有可能是Some(Some(Some(…)))這樣N多層Some的嵌套。這時，我們就可以用and_then來處理了。

利用and_then方法，我們就可以有如下的鏈式調用：

fn main() {
    assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
}

fn sq(x: u32) -> Option<u32> { 
    Some(x * x) 
}

關於Option我們就先聊到這裏，大家只需要記住，它可以用來處理空值，然後能夠使用它的一些處理方法就可以了，實在記不住這些方法，也可以在用的時候再去文檔中查詢。

Result<T, E>

聊完了Option，我們再來看另一種錯誤處理方法，它也是一個枚舉類型，叫做Result<T, E>，定義如下：

#[must_use = "this `Result` may be an `Err` variant, which should be handled"]
pub enum Result<T, E> {
    Ok(T),
    Err(E),
}

實際上，Option可以被看作Result<T, ()>。從定義中我們可以看到Result<T, E>有兩個變體：Ok(T)和Err(E)。

Result<T, E>用於處理真正意義上的錯誤，例如，當我們想要打開一個不存在的文件時，或者我們想要將一個非數字的字符串轉換爲數字時，都會得到一個Err(E)結果。

Result<T, E>的處理方法和Option類似，都可以使用unwrap和expect方法，也可以使用map和and_then方法，並且用法也都類似，這裏就不再贅述了。具體的方法使用細節可以自行查看官方文檔。

這裏我們來看一下如何處理不同類型的錯誤。

Rust在std::io模塊定義了統一的錯誤類型Error，因此我們在處理時可以分別匹配不同的錯誤類型。

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

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

    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            ErrorKind::PermissionDenied => panic!("Permission Denied!"),
            other_error => panic!("Problem opening the file: {:?}", other_error),
        },
    };
}

在處理Result<T, E>時，我們還有一種處理方法，就是**try!**宏。它會使代碼變得非常精簡，但是在發生錯誤時，會將錯誤返回，傳播到外部調用函數中，所以我們在使用之前要考慮清楚是否需要傳播錯誤。

對於上面的代碼，使用try!宏就會非常精簡。

use std::fs::File;

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

try!使用起來雖然簡單，但也有一定的問題。像我們剛纔提到的傳播錯誤，再就是有可能出現多層嵌套的情況。因此Rust引入了另一個語法糖來代替try!。它就是問號操作符“?”。

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

fn main() {
    read_username_from_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)
}

問號操作符必須在處理錯誤的代碼後面，這樣的代碼看起來更加優雅。

恐慌（Panic）

我們從最開始就聊到線程恐慌，那道理什麼是恐慌呢？

在Rust中，無法處理的錯誤就會造成線程恐慌，手動執行**panic!**宏時也會造成恐慌。當程序執行panic!宏時，會打印相應的錯誤信息，同時清理堆棧並退出。但是棧回退和清理會花費大量的時間，如果你想要立即終止程序，可以在Cargo.toml文件中[profile]區域中增加panic = 'abort'，這樣當發生恐慌時，程序會直接退出而不清理堆棧，內存空間都由操作系統來進行回收。

程序報錯時，如果你想要查看完整的錯誤棧信息，可以通過設置環境變量RUST_BACKTRACE=1的方式來實現。

如果程序發生恐慌，我們前面所說的Result<T, E>就不能使用了，Rust爲我們提供了catch_unwind方法來捕獲恐慌。

use std::panic;

fn main() {
    let result = panic::catch_unwind(|| {panic!("crash and burn")});
    assert!(result.is_err());
    println!("{}", 1 + 2);
}

在上面這段代碼中，我們手動執行一個panic宏，正常情況下，程序會在第一行退出，並不會執行後面的代碼。而這裏我們用了catch_unwind方法對panic進行了捕獲，結果如圖所示。