Module core::result

1.0.0 · source ·

Expand description

Result 类型的错误处理。

Result<T, E> 是用于返回和传播错误的类型。它是一个带有变体的枚举，Ok(T)，表示成功并包含一个值，而 Err(E) 表示错误并包含一个错误值。

enum Result<T, E> {
   Ok(T),
   Err(E),
}

Run

只要预期到错误并且可以恢复，函数就返回 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:?}"),
}

Run

在简单情况下，在 Result 上进行模式匹配非常简单明了，但是 Result 附带了一些方便的方法，使使用它更加简洁。

let good_result: Result<i32, i32> = Ok(10);
let bad_result: Result<i32, i32> = Err(10);

// `is_ok` 和 `is_err` 方法按照他们说的做。
assert!(good_result.is_ok() && !good_result.is_err());
assert!(bad_result.is_err() && !bad_result.is_ok());

// `map` 消耗 `Result` 并产生另一个。
let good_result: Result<i32, i32> = good_result.map(|i| i + 1);
let bad_result: Result<i32, i32> = bad_result.map(|i| i - 1);

// 使用 `and_then` 继续计算。
let good_result: Result<bool, i32> = good_result.and_then(|i| Ok(i == 11));

// 使用 `or_else` 处理该错误。
let bad_result: Result<i32, i32> = bad_result.or_else(|i| Ok(i + 20));

// 消费结果并用 `unwrap` 返回内容。
let final_awesome_result = good_result.unwrap();

Run

问号运算符，`?`

在编写调用许多返回 Result 类型的函数的代码时，错误处理可能很乏味。问号运算符 ? 在调用栈中隐藏了一些传播错误的样板。

它将替换为：

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 = 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(())
}

Run

有了这个：

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")?;
    // 尽早返回错误
    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(())
}

Run

好多了！

以 ? 结束表达式将导致 Ok 的展开值，除非结果为 Err，在这种情况下，Err 会从封闭的函数中提前返回。

? 可以用在返回 Result 的函数中，因为它提供了 Err 的提前返回。

可以对 Result 进行迭代。如果您需要一个条件为空的迭代器，这会很有帮助。迭代器要么产生单个值 (当 Result 为 Ok 时)，要么不产生任何值 (当 Result 为 Err 时)。例如，如果 Result 是 Ok(v)，则 into_iter 的作用类似于 once(v); 如果 Result 是 Err，则它的作用类似于 empty()。

Result<T, E> 上的迭代器分为三种类型：

into_iter 消耗 Result 并产生包含的值
iter 对包含的值产生类型为 &T 的不可变引用
iter_mut 产生一个 &mut T 类型的可变引用到包含的值

有关这如何有用的示例，请参见迭代 Option。

您可能希望使用迭代器链来执行可能失败的操作的多个实例，但希望在继续处理成功结果的同时忽略失败。在本例中，我们利用 Result 的可迭代特性，使用 flatten 仅选择 Ok 值。

let mut results = vec![];
let mut errs = vec![];
let nums: Vec<_> = ["17", "not a number", "99", "-27", "768"]
   .into_iter()
   .map(u8::from_str)
   // 保存原始 `Result` 值的克隆以进行检查
   .inspect(|x| results.push(x.clone()))
   // 挑战：解释这如何仅捕获 `Err` 值
   .inspect(|x| errs.extend(x.clone().err()))
   .flatten()
   .collect();
assert_eq!(errs.len(), 3);
assert_eq!(nums, [17, 99]);
println!("results {results:?}");
println!("errs {errs:?}");
println!("nums {nums:?}");

Run

收集到 `Result`

Result 实现了 FromIterator trait，它允许将 Result 值上的迭代器收集到原始 Result 值的每个包含值的集合的 Result 中，或者如果任何元素是 Err，则为 Err。

let v = [Ok(2), Ok(4), Err("err!"), Ok(8)];
let res: Result<Vec<_>, &str> = v.into_iter().collect();
assert_eq!(res, Err("err!"));
let v = [Ok(2), Ok(4), Ok(8)];
let res: Result<Vec<_>, &str> = v.into_iter().collect();
assert_eq!(res, Ok(vec![2, 4, 8]));

Run

Result 还实现了 Product 和 Sum traits，允许对 Result 值的迭代器提供 product 和 sum 方法。

let v = [Err("error!"), Ok(1), Ok(2), Ok(3), Err("foo")];
let res: Result<i32, &str> = v.into_iter().sum();
assert_eq!(res, Err("error!"));
let v = [Ok(1), Ok(2), Ok(21)];
let res: Result<i32, &str> = v.into_iter().product();
assert_eq!(res, Ok(42));

Run

Structs

IntoIter
Result 的 Ok 变体中的值的迭代器。
Iter
Result 的 Ok 变体的引用上的迭代器。
IterMut
Result 的 Ok 变体的可变引用上的迭代器。

Enums

Result
Result 是代表成功 (Ok) 或失败 (Err) 的类型。

method	self	input	output
`and`	`Err(e)`	(ignored)	`Err(e)`
`and`	`Ok(x)`	`Err(d)`	`Err(d)`
`and`	`Ok(x)`	`Ok(y)`	`Ok(y)`
`or`	`Err(e)`	`Err(d)`	`Err(d)`
`or`	`Err(e)`	`Ok(y)`	`Ok(y)`
`or`	`Ok(x)`	(ignored)	`Ok(x)`

method	self	function input	function result	output
`and_then`	`Err(e)`	(not provided)	(not evaluated)	`Err(e)`
`and_then`	`Ok(x)`	`x`	`Err(d)`	`Err(d)`
`and_then`	`Ok(x)`	`x`	`Ok(y)`	`Ok(y)`
`or_else`	`Err(e)`	`e`	`Err(d)`	`Err(d)`
`or_else`	`Err(e)`	`e`	`Ok(y)`	`Ok(y)`
`or_else`	`Ok(x)`	(not provided)	(not evaluated)	`Ok(x)`

Module core::result

必须使用结果

问号运算符，`?`

方法概述

查询变体

用于处理引用的适配器

提取包含的值

转换包含的值

布尔运算符

比较运算符

迭代 `Result`

收集到 `Result`

Structs

Enums