厉害很重要，但是让别人知道你很厉害更重要
大家好，我是柒八九。
今天，我们继续Rust学习笔记的探索。我们来谈谈关于枚举和匹配模式的相关知识点。
如果，想了解该系列的文章，可以参考我们已经发布的文章。如下是往期文章。
文章list
你能所学到的知识点
Rust中枚举类型 推荐阅读指数 ⭐️⭐️⭐️⭐️⭐️match控制流运算符 推荐阅读指数 ⭐️⭐️⭐️⭐️if let简单控制流 推荐阅读指数 ⭐️⭐️⭐️⭐️
好了，天不早了，干点正事哇。
{枚举|enumerations}，也被称作 enums。枚举允许你通过列举可能的{成员|variants}来定义一个类型。
定义枚举
假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。
任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。
通过在代码中定义一个 IpAddrKind 枚举来表现这个概念并列出可能的 IP 地址类型，V4 和 V6。这被称为枚举的 {成员|variants}：
enum IpAddrKind {
V4,
V6,
}
现在 IpAddrKind 就是一个可以在代码中使用的自定义数据类型了。
枚举值
可以像这样创建 IpAddrKind 两个不同成员的实例：
fn main() {
enum IpAddrKind {
V4,
V6,
}
let four = IpAddrKind::V4;
let six = IpAddrKind::V6;
}
枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。
用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。
fn main() {
enum IpAddr {
V4(u8, u8, u8, u8),
V6(String),
}
let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));
}
枚举的成员中内嵌了多种多样的类型：
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
这个枚举有四个含有不同类型的成员：
Quit没有关联任何数据。Move包含一个匿名结构体。Write包含单独一个String。ChangeColor包含三个i32。
枚举和结构体还有另一个相似点：就像可以使用
impl来为结构体定义方法那样，也可以在枚举上定义方法。
fn main() {
#[derive(Debug)]
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
impl Message {
fn call(&self) {
println!("{:?}",self)
}
}
let m = Message::Write(String::from("hello"));
m.call();
}
方法体使用了 self 来获取调用方法的值。此时输出结果为Write("hello")
Option 枚举和其相对于空值的优势
Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值。
Rust并没有很多其他语言中有的空值功能。空值（Null）是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。
然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。
问题不在于概念而在于具体的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是 Option<T>，而且它定义于标准库中，如下:
enum Option<T> {
Some(T),
None,
}
Option<T> 枚举是如此有用以至于它甚至被包含在了 prelude 之中，你不需要将其显式引入作用域。另外，它的成员也是如此，可以不需要 Option:: 前缀来直接使用 Some 和 None。即便如此 Option<T> 也仍是常规的枚举，Some(T) 和 None 仍是 Option<T> 的成员。
<T> 语法是一个泛型类型参数。目前，所有你需要知道的就是 <T> 意味着 Option 枚举的 Some 成员可以包含任意类型的数据。
let some_number = Some(5);
let some_string = Some("a string");
let absent_number: Option<i32> = None;
如果使用 None 而不是 Some，需要告诉 Rust Option<T> 是什么类型的，因为编译器只通过 None 值无法推断出 Some 成员保存的值的类型。
因为 Option<T> 和 T（这里 T 可以是任何类型）是不同的类型，编译器不允许像一个肯定有效的值那样使用 Option<T>
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y;
这段代码不能编译，因为它尝试将 Option<T> 与 i8 相加。
换句话说，在对
Option<T>进行T的运算之前必须将其转换为T。
match 控制流运算符
Rust 有一个叫做 match 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码。模式可由字面量、变量、通配符和许多其他内容构成。match 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。
可以把 match 表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会通过 match 的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用。
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
- 列出
match关键字后跟一个表达式，在这个例子中是coin的值。这看起来非常像if使用的表达式，不过这里有一个非常大的区别：对于if，表达式必须返回一个布尔值，而这里它可以是任何类型的 match的分支。一个分支有两个部分：一个模式和一些代码。- 第一个分支的模式是值
Coin::Penny - 而之后的
=> 运算符将模式和将要运行的代码分开。 - 每一个分支之间使用逗号分隔。
- 第一个分支的模式是值
当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较。如果模式匹配了这个值，这个模式相关联的代码将被执行。如果模式并不匹配这个值，将继续执行下一个分支。
每个分支相关联的代码是
一个表达式，而表达式的结果值将作为整个match表达式的返回值。
如果想要在分支中运行多行代码，可以使用大括号。
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => {
println!("输出内容");
1
}
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
匹配 Option<T>
在之前的部分中使用 Option<T> 时，是为了从 Some 中取出其内部的 T 值；我们还可以像处理 Coin 枚举那样使用 match 处理 Option<T>！只不过这回比较的不再是硬币，而是 Option<T> 的成员，但 match 表达式的工作方式保持不变。
编写一个函数，它获取一个 Option<i32> ，如果其中含有一个值，将其加一。如果其中没有值，函数应该返回 None 值，而不尝试执行任何操作
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
匹配 Some(T)
仔细地检查 plus_one 的第一行操作。当调用 plus_one(five) 时，plus_one 函数体中的 x 将会是值 Some(5)。接着将其与每个分支比较。
None => None,
值 Some(5) 并不匹配模式 None，所以继续进行下一个分支。
Some(i) => Some(i + 1),
Some(5) 与 Some(i) 匹配。它们是相同的成员。i 绑定了 Some 中包含的值，所以 i 的值是 5。接着匹配分支的代码被执行，所以我们将 i 的值加一并返回一个含有值 6 的新 Some。
匹配是穷尽的
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
Some(i) => Some(i + 1),
}
}
}
没有处理 None 的情况，所以这些代码会造成一个 bug。
Rust中的匹配是{穷举式|exhaustive}的：必须穷举到最后的可能性来使代码有效
通配模式和 _ 占位符
我们希望对一些特定的值采取特殊操作，而对其他的值采取默认操作。
想象我们正在玩一个游戏，如果你掷出骰子的值为 3，角色不会移动，而是会得到一顶新奇的帽子。如果你掷出了 7，你的角色将失去新奇的帽子。对于其他的数值，你的角色会在棋盘上移动相应的格子。
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
other => move_player(other),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}
}
对于前两个分支，匹配模式是字面值 3 和 7，最后一个分支则涵盖了所有其他可能的值，模式是我们命名为 other 的一个变量。other 分支的代码通过将其传递给 move_player 函数来使用这个变量。
Rust还提供了一个模式，当我们不想使用通配模式获取的值时，请使用 _ ，这是一个特殊的模式，可以匹配任意值而不绑定到该值。这告诉Rust我们不会使用这个值，所以Rust也不会警告我们存在未使用的变量。
改变游戏规则，当你掷出的值不是 3 或 7 的时候，你必须再次掷出
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
_ => reroll(),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn reroll() {}
}
例子满足穷举性要求，因为我们在最后一个分支中明确地忽略了其他的值。我们没有忘记处理任何东西。
if let 简单控制流
if let 语法让我们以一种不那么冗长的方式结合 if 和 let，来处理只匹配一个模式的值而忽略其他模式的情况
存在如下的程序，它匹配一个 Option<u8> 值并只希望当值为 3 时执行代码：
fn main() {
let some_u8_value = Some(0u8);
match some_u8_value {
Some(3) => println!("three"),
_ => (),
}
}
想要对 Some(3) 匹配进行操作但是不想处理任何其他 Some<u8> 值或 None 值。为了满足 match 表达式（穷尽性）的要求，必须在处理完这唯一的成员后加上 _ => ()，这样也要增加很多样板代码。
我们可以使用 if let 这种更短的方式编写。
fn main() {
let some_u8_value = Some(0u8);
if let Some(3) = some_u8_value {
println!("three");
}
}
if let 获取通过等号分隔的一个模式和一个表达式。它的工作方式与 match 相同，这里的表达式对应 match 而模式则对应第一个分支。
换句话说，可以认为
if let是match的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。
可以在 if let 中包含一个 else。else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else。
let mut count = 0;
match coin {
Coin::Quarter(state) => println!("钱的面值为{:?}!", state),
_ => count += 1,
}
使用if let 进行改写。
let mut count = 0;
if let Coin::Quarter(state) = coin {
println!("钱的面值为{:?}!", state);
} else {
count += 1;
}
如果你的程序遇到一个使用 match 表达起来过于啰嗦的逻辑，可以使用if let对其改写。
后记
分享是一种态度。
参考资料：《Rust权威指南》
全文完，既然看到这里了，如果觉得不错，随手点个赞和“在看”吧。
扫一扫
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
