1 - Rust标准库中的结果(result)介绍
https://doc.rust-lang.org/std/result/index.html
使用Result类型的错误处理。
Result<T, E>是用于返回和传播错误的类型。它是一个枚举，其中Ok(T)代表成功并包含一值，Err(E)代表错误并包含错误值。
enum Result<T, E> {
Ok(T),
Err(E),
}
函数在预计到错误并可恢复时返回Result。在 std crate 中，Result 最显著的作用是用于 I/O。
一个简单的返回Result的函数可以这样定义和使用：
#[derive(Debug)]
enum Version { Version1, Version2 }
fn parse_version(header: &[u8]) -> Result<Version, &'static str> {
match header.get(0) {
None => Err("invalid header length"),
Some(&1) => Ok(Version::Version1),
Some(&2) => Ok(Version::Version2),
Some(_) => Err("invalid version"),
}
}
let version = parse_version(&[1, 2, 3, 4]);
match version {
Ok(v) => println!("working with version: {:?}", v),
Err(e) => println!("error parsing header: {:?}", e),
}
在Result上的模式匹配对于简单的案例来说是很清晰和直接的，但是Result自带的一些方便的方法可以让工作更简洁。
let good_result: Result<i32, i32> = Ok(10);
let bad_result: Result<i32, i32> = Err(10);
// The `is_ok` and `is_err` methods do what they say.
assert!(good_result.is_ok() && !good_result.is_err());
assert!(bad_result.is_err() && !bad_result.is_ok());
// `map` consumes the `Result` and produces another.
let good_result: Result<i32, i32> = good_result.map(|i| i + 1);
let bad_result: Result<i32, i32> = bad_result.map(|i| i - 1);
// Use `and_then` to continue the computation.
let good_result: Result<bool, i32> = good_result.and_then(|i| Ok(i == 11));
// Use `or_else` to handle the error.
let bad_result: Result<i32, i32> = bad_result.or_else(|i| Ok(i + 20));
// Consume the result and return the contents with `unwrap`.
let final_awesome_result = good_result.unwrap();
结果必须使用
使用返回值来表示错误，一个常见的问题是很容易忽略返回值，从而无法处理错误。Result被注释了 #[must_use] 属性，当忽略了Result值时，编译器会发出警告。这使得Result对于可能会遇到错误但不会返回有用值的函数特别有用。
考虑一下Write属性为I/O类型定义的write_all方法。
use std::io;
trait Write {
fn write_all(&mut self, bytes: &[u8]) -> Result<(), io::Error>;
}
注意：Write的实际定义使用的是io::Result，它只是Result<T, io::Error>的同义词。
这个方法不会产生一个值，但是写的时候可能会失败。关键是要处理好错误的情况，不要这样写：
use std::fs::File;
use std::io::prelude::*;
let mut file = File::create("valuable_data.txt").unwrap();
// If `write_all` errors, then we'll never know, because the return
// value is ignored.
file.write_all(b"important message");
如果你真的在Rust中写了，编译器会给你一个警告（默认情况下，由 unused_must_use lint 控制）。
相反，如果你不想处理这个错误，你可以直接用 expect 来断言成功。如果写入失败了，这将会panic，并提供一个略微有用的消息来说明原因。
use std::fs::File;
use std::io::prelude::*;
let mut file = File::create("valuable_data.txt").unwrap();
file.write_all(b"important message").expect("failed to write message");
也可以简单地断言成功：
assert!(file.write_all(b"important message").is_ok());
或者使用 ? 将错误传播到调用栈上:
fn write_message() -> io::Result<()> {
let mut file = File::create("valuable_data.txt")?;
file.write_all(b"important message")?;
Ok(())
}
问号运算符?
当编写调用许多返回结果类型的函数的代码时，错误处理可能会很繁琐。问号操作符 ? 隐藏了一些在调用堆栈中传播错误的繁文缛节。
下面这段代码:
use std::fs::File;
use std::io::prelude::*;
use std::io;
struct Info {
name: String,
age: i32,
rating: i32,
}
fn write_info(info: &Info) -> io::Result<()> {
// Early return on error
let mut file = match File::create("my_best_friends.txt") {
Err(e) => return Err(e),
Ok(f) => f,
};
if let Err(e) = file.write_all(format!("name: {}\n", info.name).as_bytes()) {
return Err(e)
}
if let Err(e) = file.write_all(format!("age: {}\n", info.age).as_bytes()) {
return Err(e)
}
if let Err(e) = file.write_all(format!("rating: {}\n", info.rating).as_bytes()) {
return Err(e)
}
Ok(())
}
将被替代为：
use std::fs::File;
use std::io::prelude::*;
use std::io;
struct Info {
name: String,
age: i32,
rating: i32,
}
fn write_info(info: &Info) -> io::Result<()> {
let mut file = File::create("my_best_friends.txt")?;
// Early return on error
file.write_all(format!("name: {}\n", info.name).as_bytes())?;
file.write_all(format!("age: {}\n", info.age).as_bytes())?;
file.write_all(format!("rating: {}\n", info.rating).as_bytes())?;
Ok(())
}
这样就好很多了!
以 ? 结束的表达式将导致成功(Ok)值的 unwrap，除非结果是Err，在这种情况下，Err会从包围函数中提前返回。
?只能用于返回 Result 的函数中，因为它提供了 Err 的提前返回。
Result Enum
#[must_use = "this `Result` may be an `Err` variant, which should be handled"]
pub enum Result<T, E> {
Ok(T),
Err(E),
}
Result是一种类型，代表成功（Ok）或失败（Err）。
变量：
- Ok(T)： 包含成功值
- Err(E)：包含错误值
map_or 方法
对包含的值(如果有的话)应用一个函数，或者返回提供的默认值(如果没有的话)。
传递给map_or的参数会被立即求值；如果你传递的是函数调用的结果，建议使用map_or_else，它是延迟求值。
let x: Result<_, &str> = Ok("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);
let x: Result<&str, _> = Err("bar");
assert_eq!(x.map_or(42, |v| v.len()), 42);
map_or_else方法
通过将一个结果<T, E>映射到U，通过将一个函数应用到包含的Ok值，或者将一个fallback函数应用到包含的Err值。
这个函数可以用来在处理错误时解包一个成功的结果。
let k = 21;
let x : Result<_, &str> = Ok("foo");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);
let x : Result<&str, _> = Err("bar");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);