Rust中的錯(cuò)誤處理

Result枚舉

Rust 中沒有提供類似于 Java、C++ 中的 Exception 機(jī)制，而是使用Result枚舉的方式來實(shí)現(xiàn)：

pub enum Result { /// Contains the success value Ok(T), /// Contains the error value Err(E), }

在使用時(shí)：

• 如果無錯(cuò)誤則使用Ok(T)返回；

• 如果存在錯(cuò)誤，則使用Err(E)包裝錯(cuò)誤類型返回；

例如：

examples/0_result.rs

#[derive(Debug)] pub enum MyError { Internal(String), InvalidId(String), } fn add(num: i64) -> Result<i64, MyError> { if num < 0 { Err(MyError::InvalidId(String::from("Invalid num!"))) } else { Ok(num + 100000) } } fn main() -> Result<(), MyError> { // fetch_id(-1)?; let res = add(1)?; println!("{}", res); Ok(()) }

上面的代碼首先通過 MyError 枚舉定義了多個(gè)可能會出現(xiàn)的錯(cuò)誤；

隨后，在add函數(shù)中：

• 當(dāng) num 小于 0 時(shí)返回錯(cuò)誤；

• 否則給 num 增加 100000 并返回；

在上面的let res = add(1)?;中使用了?操作符，他相當(dāng)于是一個(gè)語法糖：

• 如果被調(diào)函數(shù)正常返回則調(diào)用unwrap獲取其值；

• 反之，則將被調(diào)函數(shù)的錯(cuò)誤直接向上返回（相當(dāng)于直接 return Err）；

即上面的語法糖相當(dāng)于：

let res = match add() { Ok(id) => id, Err(err) => { return Err(err); } };

錯(cuò)誤類型轉(zhuǎn)換

上面簡單展示了 Rust 中錯(cuò)誤的使用；

由于 Rust 是強(qiáng)類型的語言，因此如果在一個(gè)函數(shù)中使用?返回了多個(gè)錯(cuò)誤，并且他們的類型是不同的，還需要對返回的錯(cuò)誤類型進(jìn)行轉(zhuǎn)換，轉(zhuǎn)為相同的類型！

例如下面的例子：

#[derive(Debug)] pub enum MyError { ReadError(String), ParseError(String), } fn read_file() -> Result<i64, MyError> { // Error: Could not get compiled! let content = fs::read_to_string("/tmp/id")?; let id = content.parse::<i64>()?; } fn main() -> Result<(), MyError> { let id = read_file()?; println!("id: {}", id); Ok(()) }

上面的例子無法編譯通過，原因在于：read_to_string和parse返回的是不同類型的錯(cuò)誤！

因此，如果要能返回，我們需要對每一個(gè)錯(cuò)誤進(jìn)行轉(zhuǎn)換，轉(zhuǎn)為我們所定義的 Error 類型；

例如：

examples/1_error_convert.rs

fn read_file() -> Result<i64, MyError> { // Error: Could not get compiled! // let content = fs::read_to_string("/tmp/id")?; // let id = content.parse::()?; // Method 1: Handling error explicitly! let content = match std::read_to_string("/tmp/id") { Ok(content) => content, Err(err) => { return Err(MyError::ReadError(format!("read /tmp/id failed: {}", err))); } }; let content = content.trim(); println!("read content: {}", content); // Method 2: Use map_err to transform error type let id = content .parse::<i64>() .map_err(|err| MyError::ParseError(format!("parse error: {}", err)))?; Ok(id) }

上面展示了兩種不同的轉(zhuǎn)換 Error 的方法：

方法一通過 match 匹配手動的對read_to_string函數(shù)的返回值進(jìn)行處理，如果發(fā)生了 Error，則將錯(cuò)誤轉(zhuǎn)為我們指定類型的錯(cuò)誤；

方法二通過map_err的方式，如果返回的是錯(cuò)誤，則將其轉(zhuǎn)為我們指定的類型，這時(shí)就可以使用?返回了；

相比之下，使用 map_err 的方式，代碼會清爽很多！

From Trait

上面處理錯(cuò)誤的方法，每次都要對錯(cuò)誤的類型進(jìn)行轉(zhuǎn)換，比較麻煩；

Rust 中提供了 From Trait，在進(jìn)行類型匹配時(shí)，如果提供了從一個(gè)類型轉(zhuǎn)換為另一個(gè)類型的方法（實(shí)現(xiàn)了某個(gè)類型的 From Trait），則在編譯階段，編譯器會調(diào)用響應(yīng)的函數(shù)，直接將其轉(zhuǎn)為相應(yīng)的類型！

例如：

examples/2_from_trait.rs

#[derive(Debug)] pub enum MyError { ReadError(String), ParseError(String), } impl From for MyError { fn from(source: std::Error) -> Self { MyError::ReadError(source.to_string()) } } impl From for MyError { fn from(source: std::ParseIntError) -> Self { MyError::ParseError(source.to_string()) } } fn read_file() -> Result<i64, MyError> { let _content = fs::read_to_string("/tmp/id")?; let content = _content.trim(); let id = content.parse::<i64>()?; Ok(id) } fn main() -> Result<(), MyError> { let id = read_file()?; println!("id: {}", id); Ok(()) }

在上面的代碼中，我們?yōu)?MyError 類型的錯(cuò)誤分別實(shí)現(xiàn)了轉(zhuǎn)換為std::Error和std::ParseIntError類型的 From Trait；

因此，在 read_file 函數(shù)中就可以直接使用?向上返回錯(cuò)誤了！

但是上面的方法需要為每個(gè)錯(cuò)誤實(shí)現(xiàn) From Trait 還是有些麻煩，因此出現(xiàn)了thiserror以及anyhow庫來解決這些問題；

其他第三方庫

thiserror

上面提到了我們可以為每個(gè)錯(cuò)誤實(shí)現(xiàn) From Trait 來直接轉(zhuǎn)換錯(cuò)誤類型，thiserror庫就是使用這個(gè)邏輯；

我們可以使用 thiserror 庫提供的宏來幫助我們生成到對應(yīng)類型的 Trait；

例如：

examples/3_thiserror.rs

#[derive(thiserror::Error, Debug)] pub enum MyError { #[error("io error.")] IoError(#[from] std::Error), #[error("parse error.")] ParseError(#[from] std::ParseIntError), } fn read_file() -> Result<i64, MyError> { // Could get compiled! let content = fs::read_to_string("/tmp/id")?; let id = content.parse::<i64>()?; Ok(id) } fn main() -> Result<(), MyError> { let id = read_file()?; println!("id: {}", id); Ok(()) }

我們只需要對我們定義的類型進(jìn)行宏標(biāo)注，在編譯時(shí)這些宏會自動展開并實(shí)現(xiàn)對應(yīng)的 Trait；

展開后的代碼如下：

#![feature(prelude_import)] #[prelude_import] use std::*; #[macro_use] extern crate std; use std::fs; pub enum MyError { #[error("io error.")] IoError(#[from] std::Error), #[error("parse error.")] ParseError(#[from] std::ParseIntError), } #[allow(unused_qualifications)] impl std::Error for MyError { fn source(&self) -> std::Option<&(dyn std::Error + 'static)> { use thiserror::AsDynError; #[allow(deprecated)] match self { MyError::IoError { 0: source, .. } => std::Option::Some(source.as_dyn_error()), MyError::ParseError { 0: source, .. } => { std::Option::Some(source.as_dyn_error()) } } } } #[allow(unused_qualifications)] impl std::Display for MyError { fn fmt(&self, __formatter: &mut std::Formatter) -> std::Result { #[allow(unused_variables, deprecated, clippy::used_underscore_binding)] match self { MyError::IoError(_0) => { let result = __formatter.write_fmt(::new_v1(&["io error."], &[])); result } MyError::ParseError(_0) => { let result = __formatter.write_fmt(::new_v1(&["parse error."], &[])); result } } } } #[allow(unused_qualifications)] impl std::From for MyError { #[allow(deprecated)] fn from(source: std::Error) -> Self { MyError::IoError { 0: source } } } #[allow(unused_qualifications)] impl std::From for MyError { #[allow(deprecated)] fn from(source: std::ParseIntError) -> Self { MyError::ParseError { 0: source } } } #[automatically_derived] #[allow(unused_qualifications)] impl ::Debug for MyError { fn fmt(&self, f: &mut ::Formatter) -> ::Result { match (&*self,) { (&MyError::IoError(ref __self_0),) => { ::debug_tuple_field1_finish(f, "IoError", &&*__self_0) } (&MyError::ParseError(ref __self_0),) => { ::debug_tuple_field1_finish(f, "ParseError", &&*__self_0) } } } } fn read_file() -> Result<i64, MyError> { let content = fs::read_to_string("/tmp/id")?; let id = content.parse::<i64>()?; Ok(id) } #[allow(dead_code)] fn main() -> Result<(), MyError> { let id = read_file()?; { ::new_v1( &["id: ", " "], &[::new_display(&id)], )); }; Ok(()) } #[rustc_main] pub fn main() -> () { extern crate test; test::test_main_static(&[]) }

可以看到實(shí)際上就是為 MyError 實(shí)現(xiàn)了對應(yīng)錯(cuò)誤類型的 From Trait；

thiserror 庫的這種實(shí)現(xiàn)方式，還需要為類型指定要轉(zhuǎn)換的錯(cuò)誤類型；

而下面看到的 anyhow 庫，可以將錯(cuò)誤類型統(tǒng)一為同一種形式；

anyhow

如果你對 Go 中的錯(cuò)誤類型不陌生，那么你就可以直接上手 anyhow 了！

來看下面的例子：

examples/4_anyhow.rs

use anyhow::Result; use std::fs; fn read_file() -> Result<i64> { // Could get compiled! let content = fs::read_to_string("/tmp/id")?; let id = content.parse::<i64>()?; Ok(id) } fn main() -> Result<()> { let id = read_file()?; println!("id: {}", id); Ok(()) }

注意到，上面的 Result 類型為anyhow::Result，而非標(biāo)準(zhǔn)庫中的 Result 類型！

anyhow為Result實(shí)現(xiàn)了ContextTrait：

impl Context for Result where E: ext::StdError + Send + Sync + 'static, { fn context(self, context: C) -> Result where C: Display + Send + Sync + 'static, { // Not using map_err to save 2 useless frames off the captured backtrace // in ext_context. match self { Ok(ok) => Ok(ok), Err(error) => Err(error.ext_context(context)), } } fn with_context(self, context: F) -> Result where C: Display + Send + Sync + 'static, F: FnOnce() -> C, { match self { Ok(ok) => Ok(ok), Err(error) => Err(error.ext_context(context())), } } }

在Context中提供了context函數(shù)，并且將原來的Result轉(zhuǎn)成了Result；

因此，最終將錯(cuò)誤類型統(tǒng)一為了anyhow::Error類型；

附錄

源代碼：

• https://github.com/JasonkayZK/rust-learn/tree/error

審核編輯：湯梓紅