match 控制流运算符

ch06-02-match.md


commit 18fd30d70f4d6ee67e0a808710bf7a3135ef7ed6

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

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

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

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

示例 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. #
  8. fn value_in_cents(coin: Coin) -> u32 {
  9.     match coin {
  10.         Coin::Penny => {
  11.             println!("Lucky penny!");
  12.             1
  13.         },
  14.         Coin::Nickel => 5,
  15.         Coin::Dime => 10,
  16.         Coin::Quarter => 25,
  17.     }
  18. }

绑定值的模式

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

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

  1. #[derive(Debug)] // So we can inspect the state in a minute
  2. enum UsState {
  3.     Alabama,
  4.     Alaska,
  5.     // ... etc
  6. }
  8. enum Coin {
  9.     Penny,
  10.     Nickel,
  11.     Dime,
  12.     Quarter(UsState),
  13. }

示例 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. # }
  6. #
  7. # enum Coin {
  8. #    Penny,
  9. #    Nickel,
  10. #    Dime,
  11. #    Quarter(UsState),
  12. # }
  13. #
  14. fn value_in_cents(coin: Coin) -> u32 {
  15.     match coin {
  16.         Coin::Penny => 1,
  17.         Coin::Nickel => 5,
  18.         Coin::Dime => 10,
  19.         Coin::Quarter(state) => {
  20.             println!("State quarter from {:?}!", state);
  21.             25
  22.         },
  23.     }
  24. }

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

匹配 Option<T>

在之前的部分在使用 Option<T> 时我们想要从 Some 中取出其内部的 T 值；也可以像处理 Coin 枚举那样使用 match 处理 Option<T>！与其直接比较硬币，我们将比较 Option<T> 的成员，不过 match 表达式的工作方式保持不变。

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

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

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

示例 6-5：一个在 Option<i32> 上使用 match 表达式的函数

匹配 Some(T)

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

  1. None => None,

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

  1. Some(i) => Some(i + 1),

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

匹配 None

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

  1. None => None,

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

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

匹配是穷尽的

match 还有另一方面需要讨论。考虑一下 plus_one 函数的这个版本：

  1. fn plus_one(x: Option<i32>) -> Option<i32> {
  2.     match x {
  3.         Some(i) => Some(i + 1),
  4.     }
  5. }

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

  1. error[E0004]: non-exhaustive patterns: `None` not covered
  2.  -->
  3.   |
  4. 6 |         match x {
  5.   |               ^ pattern `None` not covered

Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 穷尽的（exhaustive）：必须穷举到最后的可能性来使代码有效。特别的在这个 Option<T> 的例子中，Rust 防止我们忘记明确的处理 None 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。

_ 通配符

Rust 也提供了一个模式用于不想列举出所有可能值的场景。例如，u8 可以拥有 0 到 255 的有效的值，如果我们只关心 1、3、5 和 7 这几个值，就并不想必须列出 0、2、4、6、8、9 一直到 255 的值。所幸我们不必这么做：可以使用特殊的模式 _ 替代：

  1. let some_u8_value = 0u8;
  2. match some_u8_value {
  3.     1 => println!("one"),
  4.     3 => println!("three"),
  5.     5 => println!("five"),
  6.     7 => println!("seven"),
  7.     _ => (),
  8. }

_ 模式会匹配所有的值。通过将其放置于其他分支之后，_ 将会匹配所有之前没有指定的可能的值。() 就是 unit 值，所以 _ 的情况什么也不会发生。因此，可以说我们想要对 _ 通配符之前没有列出的所有可能的值不做任何处理。

然而，match 在只关心 一个 情况的场景中可能就有点啰嗦了。为此 Rust 提供了if let。