match 控制流结构
Rust 有一种非常强大的控制流结构，称为 match，它允许您将一个值与一系列模式进行比较，然后根据匹配的模式执行代码。模式可以由字面值、变量名、通配符和许多其他东西组成；第 18 章涵盖了所有不同类型的模式及其作用。match 的强大之处在于模式的表达能力以及编译器确认所有可能的情况都已处理。
可以将 match 表达式想象成一台硬币分类机：硬币沿着一条轨道滑落，轨道上有各种尺寸的孔，每个硬币都会从它遇到的第一个适合的孔中掉落。同样，值会遍历 match 中的每个模式，并在值“适合”的第一个模式处，值会落入关联的代码块中，以便在执行期间使用。
说到硬币，让我们以它们为例，使用 match！我们可以编写一个函数，它接受一个未知的美国硬币，并以类似于计数机的方式确定它是哪种硬币，并以美分的形式返回其面值，如代码清单 6-3 所示。
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, } } fn main() {}
代码清单 6-3：一个枚举和一个 match 表达式，其模式是枚举的变体
让我们分解一下 value_in_cents 函数中的 match。首先，我们列出 match 关键字，后跟一个表达式，在本例中是值 coin。这看起来与 if 使用的条件表达式非常相似，但有一个很大的区别：对于 if，条件需要计算为布尔值，但这里可以是任何类型。在本例中，coin 的类型是我们第一行定义的 Coin 枚举。
接下来是 match 分支。一个分支有两个部分：一个模式和一些代码。这里的第一个分支的模式是值 Coin::Penny，然后是 => 运算符，它将模式与要运行的代码分开。在本例中，代码只是值 1。每个分支用逗号分隔。
当 match 表达式执行时，它会按顺序将结果值与每个分支的模式进行比较。如果一个模式与该值匹配，则执行与该模式关联的代码。如果该模式与该值不匹配，则执行继续到下一个分支，就像在硬币分类机中一样。我们可以根据需要拥有任意数量的分支：在代码清单 6-3 中，我们的 match 有四个分支。
与每个分支关联的代码是一个表达式，匹配分支中表达式的结果值是为整个 match 表达式返回的值。
如果匹配分支代码很短，我们通常不使用花括号，就像在代码清单 6-3 中，每个分支只返回一个值。如果要在匹配分支中运行多行代码，则必须使用花括号，然后分支后面的逗号是可选的。例如，以下代码在每次使用 Coin::Penny 调用该方法时都会打印“Lucky penny!”，但仍然返回块的最后一个值 1
enum Coin { Penny, Nickel, Dime, Quarter, } fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => { println!("Lucky penny!"); 1 } Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter => 25, } } fn main() {}
绑定到值的模式
匹配分支的另一个有用特性是它们可以绑定到与模式匹配的值的部分。这就是我们如何从枚举变体中提取值的方法。
例如，让我们更改一个枚举变体以在其内部保存数据。从 1999 年到 2008 年，美国铸造了 25 美分的硬币，每枚硬币的一面都有 50 个州的不同设计。没有其他硬币有州设计，所以只有 25 美分的硬币有这种额外的价值。我们可以通过将 Quarter 变体更改为包含存储在其内部的 UsState 值来将此信息添加到我们的 enum 中，就像我们在代码清单 6-4 中所做的那样。
#[derive(Debug)] // so we can inspect the state in a minute enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn main() {}
代码清单 6-4：一个 Coin 枚举，其中 Quarter 变体还包含一个 UsState 值
假设一位朋友正在尝试收集所有 50 个州的纪念币。当我们按硬币类型整理零钱时，我们还会说出每个 25 美分硬币上所代表的州名，这样如果我们的朋友没有这个州的硬币，他们就可以将其添加到他们的收藏中。
在这段代码的 match 表达式中，我们在匹配 Coin::Quarter 变体值的模式中添加了一个名为 state 的变量。当 Coin::Quarter 匹配时，state 变量将绑定到该 25 美分硬币所代表的州的值。然后我们可以在该分支的代码中使用 state，如下所示
#[derive(Debug)] enum UsState { Alabama, Alaska, // --snip-- } enum Coin { Penny, Nickel, Dime, Quarter(UsState), } fn value_in_cents(coin: Coin) -> u8 { match coin { Coin::Penny => 1, Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter(state) => { println!("State quarter from {state:?}!"); 25 } } } fn main() { value_in_cents(Coin::Quarter(UsState::Alaska)); }
如果我们要调用 value_in_cents(Coin::Quarter(UsState::Alaska))，则 coin 将是 Coin::Quarter(UsState::Alaska)。当我们将该值与每个 match 分支进行比较时，直到我们到达 Coin::Quarter(state) 时才会匹配。此时，state 的绑定将是值 UsState::Alaska。然后我们可以在 println! 表达式中使用该绑定，从而从 Coin 枚举变体的 Quarter 中获取内部状态值。
使用 Option<T> 进行匹配
在上一节中，我们希望在使用 Option<T> 时从 Some 情况中获取内部 T 值；我们也可以像使用 Coin 枚举一样，使用 match 处理 Option<T>！我们比较的不是硬币，而是 Option<T> 的变体，但 match 表达式的工作方式保持不变。
假设我们想编写一个函数，该函数接受一个 Option<i32>，如果里面有值，则将该值加 1。如果里面没有值，则该函数应返回 None 值，并且不尝试执行任何操作。
由于有了 match，这个函数很容易编写，看起来像代码清单 6-5。
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); }
代码清单 6-5：一个在 Option<i32> 上使用 match 表达式的函数
让我们更详细地检查一下 plus_one 的第一次执行。当我们调用 plus_one(five) 时，plus_one 主体中的变量 x 将具有值 Some(5)。然后，我们将其与每个 match 分支进行比较
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(5) 值与模式 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(5) 是否与 Some(i) 匹配？是的！我们有相同的变体。i 绑定到 Some 中包含的值，因此 i 取值为 5。然后执行 match 分支中的代码，因此我们将 i 的值加 1，并使用内部总计为 6 的新 Some 值。
现在让我们考虑代码清单 6-5 中 plus_one 的第二次调用，其中 x 为 None。我们进入 match 并与第一个分支进行比较
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);
}它匹配！没有要添加的值，因此程序停止并返回 => 右侧的 None 值。因为第一个分支匹配，所以不比较其他分支。
在许多情况下，组合使用 match 和枚举非常有用。你会在 Rust 代码中经常看到这种模式：对枚举使用 match，将变量绑定到内部数据，然后根据它执行代码。一开始这有点棘手，但一旦你习惯了，你会希望所有语言都有它。它一直是用户最喜欢的功能。
匹配是穷尽的
关于 match，我们还需要讨论另一个方面：分支的模式必须涵盖所有可能性。考虑一下我们的 plus_one 函数的这个版本，它有一个错误并且无法编译
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}我们没有处理 None 情况，因此这段代码会导致错误。幸运的是，这是一个 Rust 知道如何捕获的错误。如果我们尝试编译这段代码，我们会得到以下错误
$ cargo run
Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
--> src/main.rs:3:15
|
3 | match x {
| ^ pattern `None` not covered
|
note: `Option<i32>` defined here
--> /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/core/src/option.rs:570:1
::: /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/core/src/option.rs:574:5
|
= note: not covered
= note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
4 ~ Some(i) => Some(i + 1),
5 ~ None => todo!(),
|
For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error
Rust 知道我们没有涵盖所有可能的情况，甚至知道我们忘记了哪个模式！Rust 中的匹配是*穷尽的*：我们必须穷尽所有可能性才能使代码有效。特别是在 Option<T> 的情况下，当 Rust 阻止我们忘记显式处理 None 情况时，它可以保护我们免于在我们可能为空值时假设我们有一个值，从而避免了前面讨论的十亿美元错误。
万能模式和 _ 占位符
使用枚举，我们还可以对几个特定值采取特殊操作，但对所有其他值采取一个默认操作。假设我们正在实现一个游戏，如果你掷骰子掷出 3，你的玩家不会移动，而是会得到一顶新的漂亮帽子。如果你掷出 7，你的玩家会失去一顶漂亮帽子。对于所有其他值，你的玩家会在游戏板上移动该数字的空格数。这是一个实现该逻辑的 match，其中骰子掷出的结果是硬编码的，而不是随机值，所有其他逻辑都由没有主体的函数表示，因为实际实现它们超出了本示例的范围
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 函数来使用该变量。
这段代码可以编译，即使我们没有列出 u8 可以具有的所有可能值，因为最后一个模式将匹配所有未明确列出的值。这种万能模式满足了 match 必须穷尽的要求。请注意，我们必须将万能分支放在最后，因为模式是按顺序计算的。如果我们将万能分支放在前面，则其他分支将永远不会运行，因此如果我们在万能分支之后添加分支，Rust 会警告我们！
当我们想要一个万能模式但不想*使用*万能模式中的值时，Rust 还有一个我们可以使用的模式：_ 是一种特殊模式，它匹配任何值并且不绑定到该值。这告诉 Rust 我们不会使用该值，因此 Rust 不会警告我们有关未使用变量的信息。
让我们更改游戏规则：现在，如果你掷出的不是 3 或 7，则必须再次掷骰子。我们不再需要使用万能值，因此我们可以将代码更改为使用 _ 而不是名为 other 的变量
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() {} }
此示例也满足穷尽性要求，因为我们在最后一个分支中明确忽略了所有其他值；我们没有忘记任何事情。
最后，我们将再次更改游戏规则，以便如果你掷出的不是 3 或 7，你的回合就不会发生任何其他事情。我们可以通过使用单元值（我们在 “元组类型”部分中提到的空元组类型）作为 _ 分支的代码来表达这一点
fn main() { let dice_roll = 9; match dice_roll { 3 => add_fancy_hat(), 7 => remove_fancy_hat(), _ => (), } fn add_fancy_hat() {} fn remove_fancy_hat() {} }
在这里，我们明确告诉 Rust，我们不会使用任何其他与前面分支中的模式不匹配的值，并且我们不想在这种情况下运行任何代码。
关于模式和匹配的更多内容，我们将在 第 18 章中介绍。现在，我们将继续学习 if let 语法，这在 match 表达式有点冗长的场景中很有用。