【rCore OS 开源操作系统】Rust 异常处理
前言
虽然人还在旅游ing，但是学习不能停止，所以还是写点博客记录下。
对于 Rust 的异常处理，我的感受是：晦涩难懂，繁琐难记。
但是没办法，正如一位故人所说的：
“花钱要慎重，但是，你也得花呀！”
类似地，Rust 的异常处理虽然难学，但是呢，也得学呀！
知识点
Result 枚举值: Ok 与 Err
Rust 有个枚举值定义如下：
pub enum Result<T, E> {Ok(T),Err(E),
}
这个枚举值的完整路径是：std::result::Result，std下的大多数内容是不需要use导入的，可以直接用。
空值 ()
许多其他语言都有void关键字。
但是 Rust 没有！
在 Rust 中，等价于void空值的写法是:()，也就是下面这样：
fn main() -> Result<(), ParseIntError> {let mut tokens = 100;let pretend_user_input = "8";let cost = total_cost(pretend_user_input)?;if cost > tokens {println!("You can't afford that many!");Ok(())} else {tokens -= cost;println!("You now have {} tokens.", tokens);Ok(())}
}
简化异常处理：? 操作符
对于如下代码：
match x.parse() {Ok(parsed) => Ok(parsed),Err(e) => Err(e),
}
可以用?操作符简化为：
let parsed = x.parse()?;
使用时需要注意以下几点，否则用于简化异常处理的?操作符，反而会引起异常。
-
类型不匹配：
如果?之前的不是 Result 类型则会报错。 -
函数没有指定返回类型为 Result：
函数没有声明返回类型为 Result，但使用了 ? 操作符，编译器会报错。
当然，还有其他情况也会引起报错，不过最常见的是这两类：
这里来看一种会报错的情况：
use std::num::ParseIntError;fn main() {let mut tokens = 100;let pretend_user_input = "8";// 这里就会报错，因为没有声明返回值为 Result 类型，但是却使用了 ? 操作let cost = total_cost(pretend_user_input)?;cost
}
异常映射：map_err
map_err 是Result 类型的一个方法，将一个 Err 映射到另一个 Err 值。
- 入参：一个闭包，该闭包接受当前 Err 值作为参数。
- 返回值：返回一个新的 Result<T, E>，其中 E 是闭包返回的新错误类型。
什么叫做闭包？
这可能跟其他语言中的概念大致相同。
如果不太懂这个，其实就暂时理解为，闭包就是另一个函数/方法即可。
举个例子：
enum ParsePosNonzeroError {Creation(CreationError),ParseInt(ParseIntError),
}impl ParsePosNonzeroError {fn from_creation(err: CreationError) -> ParsePosNonzeroError {ParsePosNonzeroError::Creation(err)}fn from_parseint(err: ParseIntError) -> ParsePosNonzeroError {ParsePosNonzeroError::ParseInt(err)}
}fn parse_pos_nonzero(s: &str) -> Result<PositiveNonzeroInteger, ParsePosNonzeroError> {// 尝试将字符串解析为 Result, 这里可能产生 ParseIntErrorlet x: Result<i64, ParseIntError> = s.parse();// 第一次：ParseIntError -> ParseInt(err)let x = x.map_err(ParsePosNonzeroError::from_parseint)?;// 第二次: ParseInt(err) -> Creation(err)PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)
}
-
第一次 map_err：处理字符串解析错误，将
ParseIntError转换为ParsePosNonzeroError::ParseInt(ParseIntError)。 -
第二次 map_err：处理创建
PositiveNonzeroInteger的错误，将CreationError转换为ParsePosNonzeroError::Creation(CreationError)
这样一来，两种异常最终都是报同一种错：Creation(CreationError)。
练习题
Error1
题目
// errors1.rs
//
// This function refuses to generate text to be printed on a nametag if you pass
// it an empty string. It'd be nicer if it explained what the problem was,
// instead of just sometimes returning `None`. Thankfully, Rust has a similar
// construct to `Result` that can be used to express error conditions. Let's use
// it!
//
// Execute `rustlings hint errors1` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEpub fn generate_nametag_text(name: String) -> Option<String> {if name.is_empty() {// Empty names aren't allowed.None} else {Some(format!("Hi! My name is {}", name))}
}#[cfg(test)]
mod tests {use super::*;#[test]fn generates_nametag_text_for_a_nonempty_name() {assert_eq!(generate_nametag_text("Beyoncé".into()),Ok("Hi! My name is Beyoncé".into()));}#[test]fn explains_why_generating_nametag_text_fails() {assert_eq!(generate_nametag_text("".into()),// Don't change this lineErr("`name` was empty; it must be nonempty.".into()));}
}
题解
pub fn generate_nametag_text(name: String) -> Result<String, String> {if name.is_empty() {Err("`name` was empty; it must be nonempty.".into())} else {Ok(format!("Hi! My name is {}", name))}
}#[cfg(test)]
mod tests {use super::*;#[test]fn generates_nametag_text_for_a_nonempty_name() {assert_eq!(generate_nametag_text("Beyoncé".into()),Ok("Hi! My name is Beyoncé".into()));}#[test]fn explains_why_generating_nametag_text_fails() {assert_eq!(generate_nametag_text("".into()),// Don't change this lineErr("`name` was empty; it must be nonempty.".into()));}
}
Error2
题目
// errors2.rs
//
// Say we're writing a game where you can buy items with tokens. All items cost
// 5 tokens, and whenever you purchase items there is a processing fee of 1
// token. A player of the game will type in how many items they want to buy, and
// the `total_cost` function will calculate the total cost of the tokens. Since
// the player typed in the quantity, though, we get it as a string-- and they
// might have typed anything, not just numbers!
//
// Right now, this function isn't handling the error case at all (and isn't
// handling the success case properly either). What we want to do is: if we call
// the `parse` function on a string that is not a number, that function will
// return a `ParseIntError`, and in that case, we want to immediately return
// that error from our function and not try to multiply and add.
//
// There are at least two ways to implement this that are both correct-- but one
// is a lot shorter!
//
// Execute `rustlings hint errors2` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::num::ParseIntError;pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {let processing_fee = 1;let cost_per_item = 5;let qty = item_quantity.parse::<i32>();Ok(qty * cost_per_item + processing_fee)
}#[cfg(test)]
mod tests {use super::*;#[test]fn item_quantity_is_a_valid_number() {assert_eq!(total_cost("34"), Ok(171));}#[test]fn item_quantity_is_an_invalid_number() {assert_eq!(total_cost("beep boop").unwrap_err().to_string(),"invalid digit found in string");}
}题解
use std::num::ParseIntError;pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {let processing_fee = 1;let cost_per_item = 5;// let qty = item_quantity.parse::<i32>()?;match item_quantity.parse::<i32>() {Ok(qty) => Ok(qty * cost_per_item + processing_fee),Err(err) => Err(err),}
}#[cfg(test)]
mod tests {use super::*;#[test]fn item_quantity_is_a_valid_number() {assert_eq!(total_cost("34"), Ok(171));}#[test]fn item_quantity_is_an_invalid_number() {assert_eq!(total_cost("beep boop").unwrap_err().to_string(),"invalid digit found in string");}
}Error3
题目
// errors3.rs
//
// This is a program that is trying to use a completed version of the
// `total_cost` function from the previous exercise. It's not working though!
// Why not? What should we do to fix it?
//
// Execute `rustlings hint errors3` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::num::ParseIntError;fn main() {let mut tokens = 100;let pretend_user_input = "8";let cost = total_cost(pretend_user_input)?;if cost > tokens {println!("You can't afford that many!");} else {tokens -= cost;println!("You now have {} tokens.", tokens);}
}pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {let processing_fee = 1;let cost_per_item = 5;let qty = item_quantity.parse::<i32>()?;Ok(qty * cost_per_item + processing_fee)
}题解
use std::num::ParseIntError;fn main() -> Result<(), ParseIntError> {let mut tokens = 100;let pretend_user_input = "8";let cost = total_cost(pretend_user_input)?;if cost > tokens {println!("You can't afford that many!");Ok(())} else {tokens -= cost;println!("You now have {} tokens.", tokens);Ok(())}
}pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {let processing_fee = 1;let cost_per_item = 5;let qty = item_quantity.parse::<i32>()?;Ok(qty * cost_per_item + processing_fee)
}Error4
题目
// errors4.rs
//
// Execute `rustlings hint errors4` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONE#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {// Hmm...? Why is this only returning an Ok value?Ok(PositiveNonzeroInteger(value as u64))}
}#[test]
fn test_creation() {assert!(PositiveNonzeroInteger::new(10).is_ok());assert_eq!(Err(CreationError::Negative),PositiveNonzeroInteger::new(-10));assert_eq!(Err(CreationError::Zero), PositiveNonzeroInteger::new(0));
}题解
#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {// Hmm...? Why is this only returning an Ok value?// Ok(PositiveNonzeroInteger(value as u64))if value < 0 {Err(CreationError::Negative)} else if value == 0 {Err(CreationError::Zero)} else {Ok(PositiveNonzeroInteger(value as u64))}}
}#[test]
fn test_creation() {assert!(PositiveNonzeroInteger::new(10).is_ok());assert_eq!(Err(CreationError::Negative),PositiveNonzeroInteger::new(-10));assert_eq!(Err(CreationError::Zero), PositiveNonzeroInteger::new(0));
}Error5
题目
// errors5.rs
//
// This program uses an altered version of the code from errors4.
//
// This exercise uses some concepts that we won't get to until later in the
// course, like `Box` and the `From` trait. It's not important to understand
// them in detail right now, but you can read ahead if you like. For now, think
// of the `Box<dyn ???>` type as an "I want anything that does ???" type, which,
// given Rust's usual standards for runtime safety, should strike you as
// somewhat lenient!
//
// In short, this particular use case for boxes is for when you want to own a
// value and you care only that it is a type which implements a particular
// trait. To do so, The Box is declared as of type Box<dyn Trait> where Trait is
// the trait the compiler looks for on any value used in that context. For this
// exercise, that context is the potential errors which can be returned in a
// Result.
//
// What can we use to describe both errors? In other words, is there a trait
// which both errors implement?
//
// Execute `rustlings hint errors5` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::error;
use std::fmt;
use std::num::ParseIntError;// TODO: update the return type of `main()` to make this compile.
fn main() -> Result<(), Box<dyn ???>> {let pretend_user_input = "42";let x: i64 = pretend_user_input.parse()?;println!("output={:?}", PositiveNonzeroInteger::new(x)?);Ok(())
}// Don't change anything below this line.#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {match value {x if x < 0 => Err(CreationError::Negative),x if x == 0 => Err(CreationError::Zero),x => Ok(PositiveNonzeroInteger(x as u64)),}}
}// This is required so that `CreationError` can implement `error::Error`.
impl fmt::Display for CreationError {fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {let description = match *self {CreationError::Negative => "number is negative",CreationError::Zero => "number is zero",};f.write_str(description)}
}impl error::Error for CreationError {}题解
use std::error;
use std::error::Error;
use std::fmt;
use std::num::ParseIntError;fn main() -> Result<(), Box<dyn Error>> {let pretend_user_input = "42";let x: i64 = pretend_user_input.parse()?;println!("output={:?}", PositiveNonzeroInteger::new(x)?);Ok(())
}// Don't change anything below this line.#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {match value {x if x < 0 => Err(CreationError::Negative),x if x == 0 => Err(CreationError::Zero),x => Ok(PositiveNonzeroInteger(x as u64)),}}
}impl fmt::Display for CreationError {fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {let description = match *self {CreationError::Negative => "number is negative",CreationError::Zero => "number is zero",};f.write_str(description)}
}impl error::Error for CreationError {}
Error6
题目
// errors6.rs
//
// Using catch-all error types like `Box<dyn error::Error>` isn't recommended
// for library code, where callers might want to make decisions based on the
// error content, instead of printing it out or propagating it further. Here, we
// define a custom error type to make it possible for callers to decide what to
// do next when our function returns an error.
//
// Execute `rustlings hint errors6` or use the `hint` watch subcommand for a
// hint.// I AM NOT DONEuse std::num::ParseIntError;// This is a custom error type that we will be using in `parse_pos_nonzero()`.
#[derive(PartialEq, Debug)]
enum ParsePosNonzeroError {Creation(CreationError),ParseInt(ParseIntError),
}impl ParsePosNonzeroError {fn from_creation(err: CreationError) -> ParsePosNonzeroError {ParsePosNonzeroError::Creation(err)}// TODO: add another error conversion function here.// fn from_parseint...
}fn parse_pos_nonzero(s: &str) -> Result<PositiveNonzeroInteger, ParsePosNonzeroError> {// TODO: change this to return an appropriate error instead of panicking// when `parse()` returns an error.let x: i64 = s.parse().unwrap();PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)
}// Don't change anything below this line.#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {match value {x if x < 0 => Err(CreationError::Negative),x if x == 0 => Err(CreationError::Zero),x => Ok(PositiveNonzeroInteger(x as u64)),}}
}#[cfg(test)]
mod test {use super::*;#[test]fn test_parse_error() {// We can't construct a ParseIntError, so we have to pattern match.assert!(matches!(parse_pos_nonzero("not a number"),Err(ParsePosNonzeroError::ParseInt(_))));}#[test]fn test_negative() {assert_eq!(parse_pos_nonzero("-555"),Err(ParsePosNonzeroError::Creation(CreationError::Negative)));}#[test]fn test_zero() {assert_eq!(parse_pos_nonzero("0"),Err(ParsePosNonzeroError::Creation(CreationError::Zero)));}#[test]fn test_positive() {let x = PositiveNonzeroInteger::new(42);assert!(x.is_ok());assert_eq!(parse_pos_nonzero("42"), Ok(x.unwrap()));}
}题解
use std::num::ParseIntError;#[derive(PartialEq, Debug)]
enum ParsePosNonzeroError {Creation(CreationError),ParseInt(ParseIntError),
}impl ParsePosNonzeroError {fn from_creation(err: CreationError) -> ParsePosNonzeroError {ParsePosNonzeroError::Creation(err)}fn from_parseint(err: ParseIntError) -> ParsePosNonzeroError {ParsePosNonzeroError::ParseInt(err)}
}fn parse_pos_nonzero(s: &str) -> Result<PositiveNonzeroInteger, ParsePosNonzeroError> {// 尝试将字符串解析为 i64 类型let x: Result<i64, ParseIntError> = s.parse();let x = x.map_err(ParsePosNonzeroError::from_parseint)?;PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)
}#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);#[derive(PartialEq, Debug)]
enum CreationError {Negative,Zero,
}impl PositiveNonzeroInteger {fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {match value {x if x < 0 => Err(CreationError::Negative),x if x == 0 => Err(CreationError::Zero),x => Ok(PositiveNonzeroInteger(x as u64)),}}
}#[cfg(test)]
mod test {use super::*;#[test]fn test_parse_error() {assert!(matches!(parse_pos_nonzero("not a number"),Err(ParsePosNonzeroError::ParseInt(_))));}#[test]fn test_negative() {assert_eq!(parse_pos_nonzero("-555"),Err(ParsePosNonzeroError::Creation(CreationError::Negative)));}#[test]fn test_zero() {assert_eq!(parse_pos_nonzero("0"),Err(ParsePosNonzeroError::Creation(CreationError::Zero)));}#[test]fn test_positive() {let x = PositiveNonzeroInteger::new(42);assert!(x.is_ok());assert_eq!(parse_pos_nonzero("42"), Ok(x.unwrap()));}
}