match 控制流结构

ch06-02-match.md
commit c76f1b4d011fe59fc4f5e6f258070fc40d9921e4

Rust 有一个叫做 match 的极为强大的控制流运算符,它允许我们将一个值与一系列的模式相比较,并根据相匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成;第十八章会涉及到所有不同种类的模式以及它们的作用。match 的力量来源于模式的表现力以及编译器检查,它确保了所有可能的情况都得到处理。

可以把 match 表达式想象成某种硬币分类器:硬币滑入有着不同大小孔洞的轨道,每一个硬币都会掉入符合它大小的孔洞。同样地,值也会通过 match 的每一个模式,并且在遇到第一个 “符合” 的模式时,值会进入相关联的代码块并在执行中被使用。

因为刚刚提到了硬币,让我们用它们来作为一个使用 match 的例子!我们可以编写一个函数来获取一个未知的硬币,并以一种类似验钞机的方式,确定它是何种硬币并返回它的美分值,如示例 6-3 中所示。

  1. enum Coin {
  2. Penny,
  3. Nickel,
  4. Dime,
  5. Quarter,
  6. }
  7. fn value_in_cents(coin: Coin) -> u8 {
  8. match coin {
  9. Coin::Penny => 1,
  10. Coin::Nickel => 5,
  11. Coin::Dime => 10,
  12. Coin::Quarter => 25,
  13. }
  14. }
  15. fn main() {}

示例 6-3:一个枚举和一个以枚举成员作为模式的 match 表达式

拆开 value_in_cents 函数中的 match 来看。首先,我们列出 match 关键字后跟一个表达式,在这个例子中是 coin 的值。这看起来非常像 if 使用的表达式,不过这里有一个非常大的区别:对于 if,表达式必须返回一个布尔值,而这里它可以是任何类型的。例子中的 coin 的类型是示例 6-3 中定义的 Coin 枚举。

接下来是 match 的分支。一个分支有两个部分:一个模式和一些代码。第一个分支的模式是值 Coin::Penny 而之后的 => 运算符将模式和将要运行的代码分开。这里的代码就仅仅是值 1。每一个分支之间使用逗号分隔。

match 表达式执行时,它将结果值按顺序与每一个分支的模式相比较。如果模式匹配了这个值,这个模式相关联的代码将被执行。如果模式并不匹配这个值,将继续执行下一个分支,非常类似一个硬币分类器。可以拥有任意多的分支:示例 6-3 中的 match 有四个分支。

每个分支相关联的代码是一个表达式,而表达式的结果值将作为整个 match 表达式的返回值。

如果分支代码较短的话通常不使用大括号,正如示例 6-3 中的每个分支都只是返回一个值。如果想要在分支中运行多行代码,可以使用大括号,而分支后的逗号是可选的。例如,如下代码在每次使用Coin::Penny 调用时都会打印出 “Lucky penny!”,同时仍然返回代码块最后的值,1

  1. enum Coin {
  2. Penny,
  3. Nickel,
  4. Dime,
  5. Quarter,
  6. }
  7. fn value_in_cents(coin: Coin) -> u8 {
  8. match coin {
  9. Coin::Penny => {
  10. println!("Lucky penny!");
  11. 1
  12. }
  13. Coin::Nickel => 5,
  14. Coin::Dime => 10,
  15. Coin::Quarter => 25,
  16. }
  17. }
  18. fn main() {}

绑定值的模式

匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值的。

作为一个例子,让我们修改枚举的一个成员来存放数据。1999 年到 2008 年间,美国在 25 美分的硬币的一侧为 50 个州的每一个都印刷了不同的设计。其他的硬币都没有这种区分州的设计,所以只有这些 25 美分硬币有特殊的价值。可以将这些信息加入我们的 enum,通过改变 Quarter 成员来包含一个 State 值,示例 6-4 中完成了这些修改:

  1. #[derive(Debug)] // 这样可以立刻看到州的名称
  2. enum UsState {
  3. Alabama,
  4. Alaska,
  5. // --snip--
  6. }
  7. enum Coin {
  8. Penny,
  9. Nickel,
  10. Dime,
  11. Quarter(UsState),
  12. }
  13. fn main() {}

示例 6-4:Quarter 成员也存放了一个 UsState 值的 Coin 枚举

想象一下我们的一个朋友尝试收集所有 50 个州的 25 美分硬币。在根据硬币类型分类零钱的同时,也可以报告出每个 25 美分硬币所对应的州名称,这样如果我们的朋友没有的话,他可以将其加入收藏。

在这些代码的匹配表达式中,我们在匹配 Coin::Quarter 成员的分支的模式中增加了一个叫做 state 的变量。当匹配到 Coin::Quarter 时,变量 state 将会绑定 25 美分硬币所对应州的值。接着在那个分支的代码中使用 state,如下:

  1. #[derive(Debug)]
  2. enum UsState {
  3. Alabama,
  4. Alaska,
  5. // --snip--
  6. }
  7. enum Coin {
  8. Penny,
  9. Nickel,
  10. Dime,
  11. Quarter(UsState),
  12. }
  13. fn value_in_cents(coin: Coin) -> u8 {
  14. match coin {
  15. Coin::Penny => 1,
  16. Coin::Nickel => 5,
  17. Coin::Dime => 10,
  18. Coin::Quarter(state) => {
  19. println!("State quarter from {:?}!", state);
  20. 25
  21. }
  22. }
  23. }
  24. fn main() {
  25. value_in_cents(Coin::Quarter(UsState::Alaska));
  26. }

如果调用 value_in_cents(Coin::Quarter(UsState::Alaska))coin 将是 Coin::Quarter(UsState::Alaska)。当将值与每个分支相比较时,没有分支会匹配,直到遇到 Coin::Quarter(state)。这时,state 绑定的将会是值 UsState::Alaska。接着就可以在 println! 表达式中使用这个绑定了,像这样就可以获取 Coin 枚举的 Quarter 成员中内部的州的值。

匹配 Option

我们在之前的部分中使用 Option 时,是为了从 Some 中取出其内部的 T 值;我们还可以像处理 Coin 枚举那样使用 match 处理 Option!只不过这回比较的不再是硬币,而是 Option 的成员,但 match 表达式的工作方式保持不变。

比如我们想要编写一个函数,它获取一个 Option ,如果其中含有一个值,将其加一。如果其中没有值,函数应该返回 None 值,而不尝试执行任何操作。

得益于 match,编写这个函数非常简单,它将看起来像示例 6-5 中这样:

  1. fn main() {
  2. fn plus_one(x: Option<i32>) -> Option<i32> {
  3. match x {
  4. None => None,
  5. Some(i) => Some(i + 1),
  6. }
  7. }
  8. let five = Some(5);
  9. let six = plus_one(five);
  10. let none = plus_one(None);
  11. }

示例 6-5:一个在 Option 上使用 match 表达式的函数

匹配 Some(T)

让我们更仔细地检查 plus_one 的第一行操作。当调用 plus_one(five) 时,plus_one 函数体中的 x 将会是值 Some(5)。接着将其与每个分支比较。

  1. fn main() {
  2. fn plus_one(x: Option<i32>) -> Option<i32> {
  3. match x {
  4. None => None,
  5. Some(i) => Some(i + 1),
  6. }
  7. }
  8. let five = Some(5);
  9. let six = plus_one(five);
  10. let none = plus_one(None);
  11. }

Some(5) 并不匹配模式 None,所以继续进行下一个分支。

  1. fn main() {
  2. fn plus_one(x: Option<i32>) -> Option<i32> {
  3. match x {
  4. None => None,
  5. Some(i) => Some(i + 1),
  6. }
  7. }
  8. let five = Some(5);
  9. let six = plus_one(five);
  10. let none = plus_one(None);
  11. }

Some(5)Some(i) 匹配吗?当然匹配!它们是相同的成员。i 绑定了 Some 中包含的值,所以 i 的值是 5。接着匹配分支的代码被执行,所以我们将 i 的值加一并返回一个含有值 6 的新 Some

接着考虑下示例 6-5 中 plus_one 的第二个调用,这里 xNone。我们进入 match 并与第一个分支相比较。

  1. fn main() {
  2. fn plus_one(x: Option<i32>) -> Option<i32> {
  3. match x {
  4. None => None,
  5. Some(i) => Some(i + 1),
  6. }
  7. }
  8. let five = Some(5);
  9. let six = plus_one(five);
  10. let none = plus_one(None);
  11. }

匹配上了!这里没有值来加一,所以程序结束并返回 => 右侧的值 None,因为第一个分支就匹配到了,其他的分支将不再比较。

match 与枚举相结合在很多场景中都是有用的。你会在 Rust 代码中看到很多这样的模式:match 一个枚举,绑定其中的值到一个变量,接着根据其值执行代码。这在一开始有点复杂,不过一旦习惯了,你会希望所有语言都拥有它!这一直是用户的最爱。

匹配是穷尽的

match 还有另一方面需要讨论:这些分支必须覆盖了所有的可能性。考虑一下 plus_one 函数的这个版本,它有一个 bug 并不能编译:

  1. fn main() {
  2. fn plus_one(x: Option<i32>) -> Option<i32> {
  3. match x {
  4. Some(i) => Some(i + 1),
  5. }
  6. }
  7. let five = Some(5);
  8. let six = plus_one(five);
  9. let none = plus_one(None);
  10. }

我们没有处理 None 的情况,所以这些代码会造成一个 bug。幸运的是,这是一个 Rust 知道如何处理的 bug。如果尝试编译这段代码,会得到这个错误:

  1. $ cargo run
  2. Compiling enums v0.1.0 (file:///projects/enums)
  3. error[E0004]: non-exhaustive patterns: `None` not covered
  4. --> src/main.rs:3:15
  5. |
  6. 3 | match x {
  7. | ^ pattern `None` not covered
  8. |
  9. = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
  10. = note: the matched value is of type `Option<i32>`
  11. For more information about this error, try `rustc --explain E0004`.
  12. error: could not compile `enums` due to previous error

Rust 知道我们没有覆盖所有可能的情况甚至知道哪些模式被忘记了!Rust 中的匹配是 穷尽的exhaustive):必须穷举到最后的可能性来使代码有效。特别的在这个 Option 的例子中,Rust 防止我们忘记明确的处理 None 的情况,这让我们免于假设拥有一个实际上为空的值,从而使之前提到的价值亿万的错误不可能发生。

通配模式和 _ 占位符

让我们看一个例子,我们希望对一些特定的值采取特殊操作,而对其他的值采取默认操作。想象我们正在玩一个游戏,如果你掷出骰子的值为 3,角色不会移动,而是会得到一顶新奇的帽子。如果你掷出了 7,你的角色将失去新奇的帽子。对于其他的数值,你的角色会在棋盘上移动相应的格子。这是一个实现了上述逻辑的 match,骰子的结果是硬编码而不是一个随机值,其他的逻辑部分使用了没有函数体的函数来表示,实现它们超出了本例的范围:

  1. fn main() {
  2. let dice_roll = 9;
  3. match dice_roll {
  4. 3 => add_fancy_hat(),
  5. 7 => remove_fancy_hat(),
  6. other => move_player(other),
  7. }
  8. fn add_fancy_hat() {}
  9. fn remove_fancy_hat() {}
  10. fn move_player(num_spaces: u8) {}
  11. }

对于前两个分支,匹配模式是字面值 3 和 7,最后一个分支则涵盖了所有其他可能的值,模式是我们命名为 other 的一个变量。other 分支的代码通过将其传递给 move_player 函数来使用这个变量。

即使我们没有列出 u8 所有可能的值,这段代码依然能够编译,因为最后一个模式将匹配所有未被特殊列出的值。这种通配模式满足了 match 必须被穷尽的要求。请注意,我们必须将通配分支放在最后,因为模式是按顺序匹配的。如果我们在通配分支后添加其他分支,Rust 将会警告我们,因为此后的分支永远不会被匹配到。

Rust 还提供了一个模式,当我们不想使用通配模式获取的值时,请使用 _ ,这是一个特殊的模式,可以匹配任意值而不绑定到该值。这告诉 Rust 我们不会使用这个值,所以 Rust 也不会警告我们存在未使用的变量。

让我们改变游戏规则:现在,当你掷出的值不是 3 或 7 的时候,你必须再次掷出。这种情况下我们不需要使用这个值,所以我们改动代码使用 _ 来替代变量 other

  1. fn main() {
  2. let dice_roll = 9;
  3. match dice_roll {
  4. 3 => add_fancy_hat(),
  5. 7 => remove_fancy_hat(),
  6. _ => reroll(),
  7. }
  8. fn add_fancy_hat() {}
  9. fn remove_fancy_hat() {}
  10. fn reroll() {}
  11. }

这个例子也满足穷举性要求,因为我们在最后一个分支中明确地忽略了其他的值。我们没有忘记处理任何东西。

最后,让我们再次改变游戏规则,如果你掷出 3 或 7 以外的值,你的回合将无事发生。我们可以使用单元值(在“元组类型”一节中提到的空元组)作为 _ 分支的代码:

  1. fn main() {
  2. let dice_roll = 9;
  3. match dice_roll {
  4. 3 => add_fancy_hat(),
  5. 7 => remove_fancy_hat(),
  6. _ => (),
  7. }
  8. fn add_fancy_hat() {}
  9. fn remove_fancy_hat() {}
  10. }

在这里,我们明确告诉 Rust 我们不会使用与前面模式不匹配的值,并且这种情况下我们不想运行任何代码。

我们将在第 18 章中介绍更多关于模式和匹配的内容。现在,让我们继续讨论 if let 语法,这在 match 表达式有点啰嗦的情况下很有用。