17.錯誤處理

錯誤處理是保證程序健壯性的前提，在編程語言中錯誤處理的方式大致分為兩種：拋出異常（exceptions）和作為值返回。

Rust 將錯誤作為值返回並且提供了原生的優雅的錯誤處理方案。

熟練掌握錯誤處理是軟件工程中非常重要的環節，讓我一起來看看Rust展現給我們的錯誤處理藝術。

17.1 Option和Result

謹慎使用panic：

fn guess(n: i32) -> bool {
    if n < 1 || n > 10 {
        panic!("Invalid number: {}", n);
    }
    n == 5
}

fn main() {
    guess(11);
}

panic會導致當前線程結束，甚至是整個程序的結束，這往往是不被期望看到的結果。（編寫示例或者簡短代碼的時候panic不失為一個好的建議）

Option

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option 是Rust的系統類型，用來表示值不存在的可能，這在編程中是一個好的實踐，它強制Rust檢測和處理值不存在的情況。例如：

#![allow(unused)]
fn main() {
fn find(haystack: &str, needle: char) -> Option<usize> {
    for (offset, c) in haystack.char_indices() {
        if c == needle {
            return Some(offset);
        }
    }
    None
}
}

find在字符串haystack中查找needle字符，事實上結果會出現兩種可能，有（Some(usize))或無（None）。

fn main() {
    let file_name = "foobar.rs";
    match find(file_name, '.') {
        None => println!("No file extension found."),
        Some(i) => println!("File extension: {}", &file_name[i+1..]),
    }
}

Rust 使用模式匹配來處理返回值，調用者必須處理結果為None的情況。這往往是一個好的編程習慣，可以減少潛在的bug。Option 包含一些方法來簡化模式匹配，畢竟過多的match會使代碼變得臃腫，這也是滋生bug的原因之一。

unwrap

#![allow(unused)]
fn main() {
impl<T> Option<T> {
    fn unwrap(self) -> T {
        match self {
            Option::Some(val) => val,
            Option::None =>
              panic!("called `Option::unwrap()` on a `None` value"),
        }
    }
}
}

unwrap當遇到None值時會panic，如前面所說這不是一個好的工程實踐。不過有些時候卻非常有用：

在例子和簡單快速的編碼中 有的時候你只是需要一個小例子或者一個簡單的小程序，輸入輸出已經確定，你根本沒必要花太多時間考慮錯誤處理，使用unwrap變得非常合適。
當程序遇到了致命的bug，panic是最優選擇

map

假如我們要在一個字符串中找到文件的擴展名，比如foo.rs中的rs，我們可以這樣：

fn extension_explicit(file_name: &str) -> Option<&str> {
    match find(file_name, '.') {
        None => None,
        Some(i) => Some(&file_name[i+1..]),
    }
}

fn main() {
    match extension_explicit("foo.rs") {
        None => println!("no extension"),
        Some(ext) =>  assert_eq!(ext, "rs"),
    }
}

我們可以使用map簡化：

#![allow(unused)]
fn main() {
// map是標準庫中的方法
fn map<F, T, A>(option: Option<T>, f: F) -> Option<A> where F: FnOnce(T) -> A {
    match option {
        None => None,
        Some(value) => Some(f(value)),
    }
}
// 使用map去掉match
fn extension(file_name: &str) -> Option<&str> {
    find(file_name, '.').map(|i| &file_name[i+1..])
}
}

map如果有值Some(T)會執行f，反之直接返回None。

unwrap_or

#![allow(unused)]
fn main() {
fn unwrap_or<T>(option: Option<T>, default: T) -> T {
    match option {
        None => default,
        Some(value) => value,
    }
}
}

unwrap_or提供了一個默認值default，當值為None時返回default：

fn main() {
    assert_eq!(extension("foo.rs").unwrap_or("rs"), "rs");
    assert_eq!(extension("foo").unwrap_or("rs"), "rs");
}

and_then

#![allow(unused)]
fn main() {
fn and_then<F, T, A>(option: Option<T>, f: F) -> Option<A>
        where F: FnOnce(T) -> Option<A> {
    match option {
        None => None,
        Some(value) => f(value),
    }
}
}

看起來and_then和map差不多，不過map只是把值為Some(t)重新映射了一遍，and_then則會返回另一個Option。如果我們在一個文件路徑中找到它的擴展名，這時候就會變得尤為重要：

#![allow(unused)]
fn main() {
use std::path::Path;
fn file_name(file_path: &str) -> Option<&str> {
    let path = Path::new(file_path);
    path.file_name().to_str()
}
fn file_path_ext(file_path: &str) -> Option<&str> {
    file_name(file_path).and_then(extension)
}
}

Result

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Result是Option的更通用的版本，比起Option結果為None它解釋了結果錯誤的原因，所以：

#![allow(unused)]
fn main() {
type Option<T> = Result<T, ()>;
}

這樣的別名是一樣的（()標示空元組，它既是()類型也可以是()值）

unwrap

#![allow(unused)]
fn main() {
impl<T, E: ::std::fmt::Debug> Result<T, E> {
    fn unwrap(self) -> T {
        match self {
            Result::Ok(val) => val,
            Result::Err(err) =>
              panic!("called `Result::unwrap()` on an `Err` value: {:?}", err),
        }
    }
}
}

沒錯和Option一樣，事實上它們擁有很多類似的方法，不同的是，Result包括了錯誤的詳細描述，這對於調試人員來說，這是友好的。

Result我們從例子開始

fn double_number(number_str: &str) -> i32 {
    2 * number_str.parse::<i32>().unwrap()
}

fn main() {
    let n: i32 = double_number("10");
    assert_eq!(n, 20);
}

double_number從一個字符串中解析出一個i32的數字並*2，main中調用看起來沒什麼問題，但是如果把"10"換成其他解析不了的字符串程序便會panic

#![allow(unused)]
fn main() {
impl str {
    fn parse<F: FromStr>(&self) -> Result<F, F::Err>;
}

}

parse返回一個Result，但讓我們也可以返回一個Option，畢竟一個字符串要麼能解析成一個數字要麼不能，但是Result給我們提供了更多的信息（要麼是一個空字符串，一個無效的數位，太大或太小），這對於使用者是友好的。當你面對一個Option和Result之間的選擇時。如果你可以提供詳細的錯誤信息，那麼大概你也應該提供。

這裡需要理解一下FromStr這個trait:

#![allow(unused)]
fn main() {
pub trait FromStr {
    type Err;
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}

impl FromStr for i32 {
    type Err = ParseIntError;
    fn from_str(src: &str) -> Result<i32, ParseIntError> {

    }
}
}

number_str.parse::<i32>()事實上調用的是i32的FromStr實現。

我們需要改寫這個例子：

use std::num::ParseIntError;

fn double_number(number_str: &str) -> Result<i32, ParseIntError> {
    number_str.parse::<i32>().map(|n| 2 * n)
}

fn main() {
    match double_number("10") {
        Ok(n) => assert_eq!(n, 20),
        Err(err) => println!("Error: {:?}", err),
    }
}

不僅僅是map，Result同樣包含了unwrap_or和and_then。也有一些特有的針對錯誤類型的方法map_err和or_else。

Result別名

在Rust的標準庫中會經常出現Result的別名，用來默認確認其中Ok(T)或者Err(E)的類型，這能減少重複編碼。比如io::Result

#![allow(unused)]
fn main() {
use std::num::ParseIntError;
use std::result;

type Result<T> = result::Result<T, ParseIntError>;

fn double_number(number_str: &str) -> Result<i32> {
    unimplemented!();
}
}

組合Option和Result

Option的方法ok_or：

#![allow(unused)]
fn main() {
fn ok_or<T, E>(option: Option<T>, err: E) -> Result<T, E> {
    match option {
        Some(val) => Ok(val),
        None => Err(err),
    }
}
}

可以在值為None的時候返回一個Result::Err(E)，值為Some(T)的時候返回Ok(T)，利用它我們可以組合Option和Result：

use std::env;

fn double_arg(mut argv: env::Args) -> Result<i32, String> {
    argv.nth(1)
        .ok_or("Please give at least one argument".to_owned())
        .and_then(|arg| arg.parse::<i32>().map_err(|err| err.to_string()))
        .map(|n| 2 * n)
}

fn main() {
    match double_arg(env::args()) {
        Ok(n) => println!("{}", n),
        Err(err) => println!("Error: {}", err),
    }
}

double_arg將傳入的命令行參數轉化為數字並翻倍，ok_or將Option類型轉換成Result，map_err當值為Err(E)時調用作為參數的函數處理錯誤

複雜的例子

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

fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, String> {
    File::open(file_path)
         .map_err(|err| err.to_string())
         .and_then(|mut file| {
              let mut contents = String::new();
              file.read_to_string(&mut contents)
                  .map_err(|err| err.to_string())
                  .map(|_| contents)
         })
         .and_then(|contents| {
              contents.trim().parse::<i32>()
                      .map_err(|err| err.to_string())
         })
         .map(|n| 2 * n)
}

fn main() {
    match file_double("foobar") {
        Ok(n) => println!("{}", n),
        Err(err) => println!("Error: {}", err),
    }
}

file_double從文件中讀取內容並將其轉化成i32類型再翻倍。這個例子看起來已經很複雜了，它使用了多個組合方法，我們可以使用傳統的match和if let來改寫它：

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

fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, String> {
    let mut file = match File::open(file_path) {
        Ok(file) => file,
        Err(err) => return Err(err.to_string()),
    };
    let mut contents = String::new();
    if let Err(err) = file.read_to_string(&mut contents) {
        return Err(err.to_string());
    }
    let n: i32 = match contents.trim().parse() {
        Ok(n) => n,
        Err(err) => return Err(err.to_string()),
    };
    Ok(2 * n)
}

fn main() {
    match file_double("foobar") {
        Ok(n) => println!("{}", n),
        Err(err) => println!("Error: {}", err),
    }
}

這兩種方法個人認為都是可以的，依具體情況來取捨。

try!

#![allow(unused)]
fn main() {
macro_rules! try {
    ($e:expr) => (match $e {
        Ok(val) => val,
        Err(err) => return Err(::std::convert::From::from(err)),
    });
}

}

try!事實上就是match Result的封裝，當遇到Err(E)時會提早返回， ::std::convert::From::from(err)可以將不同的錯誤類型返回成最終需要的錯誤類型，因為所有的錯誤都能通過From轉化成Box<Error>，所以下面的代碼是正確的：

#![allow(unused)]
fn main() {
use std::error::Error;
use std::fs::File;
use std::io::Read;
use std::path::Path;

fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, Box<Error>> {
    let mut file = try!(File::open(file_path));
    let mut contents = String::new();
    try!(file.read_to_string(&mut contents));
    let n = try!(contents.trim().parse::<i32>());
    Ok(2 * n)
}

}

組合自定義錯誤類型

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};
use std::num;
use std::io;
use std::path::Path;

// We derive `Debug` because all types should probably derive `Debug`.
// This gives us a reasonable human readable description of `CliError` values.
#[derive(Debug)]
enum CliError {
    Io(io::Error),
    Parse(num::ParseIntError),
}

impl From<io::Error> for CliError {
    fn from(err: io::Error) -> CliError {
        CliError::Io(err)
    }
}

impl From<num::ParseIntError> for CliError {
    fn from(err: num::ParseIntError) -> CliError {
        CliError::Parse(err)
    }
}

fn file_double_verbose<P: AsRef<Path>>(file_path: P) -> Result<i32, CliError> {
    let mut file = try!(File::open(file_path).map_err(CliError::Io));
    let mut contents = String::new();
    try!(file.read_to_string(&mut contents).map_err(CliError::Io));
    let n: i32 = try!(contents.trim().parse().map_err(CliError::Parse));
    Ok(2 * n)
}
}

CliError分別為io::Error和num::ParseIntError實現了From這個trait，所有調用try!的時候這兩種錯誤類型都能轉化成CliError。

總結

熟練使用Option和Result是編寫 Rust 代碼的關鍵，Rust 優雅的錯誤處理離不開值返回的錯誤形式，編寫代碼時提供給使用者詳細的錯誤信息是值得推崇的。

Keyboard shortcuts

RustPrimer - Rust 中文入門書