枚举和模式匹配

枚举的定义

结构体给予你将字段和数据聚合在一起的方法，像 Rectangle 结构体有 width 和 height 两个字段。而枚举给予你一个途径去声明某个值是一个集合中的一员。

假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4 和 IPv6。这是程序可能会遇到的所有可能的 IP 地址类型：所以可以枚举出所有可能的值，这也正是此枚举名字的由来。

任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理适用于任何类型的 IP 地址的场景时应该把它们当作相同的类型。

可以通过在代码中定义一个 IpAddrKind 枚举来表现这个概念并列出可能的 IP 地址类型，V4 和 V6。这被称为枚举的 成员：

enum IpAddrKind {V4,V6,
}

现在 IpAddrKind 就是一个可以在代码中使用的自定义数据类型了。这样就可以创建 IpAddrKind 两个不同成员的实例：

let four = IpAddeKind::V4;
let six = IpAddeKind::V6;

注意枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。这么设计的益处是现在 IpAddrKind::V4 和 IpAddrKind::V6 都是 IpAddrKind 类型的。例如，接着可以定义一个函数来接收任何 IpAddrKind类型的参数，使用任一成员来调用这个函数：

enum IpAddrKind {V4,V6,
}fn main() {let four = IpAddrKind::V4;let six = IpAddrKind::V6;route(IpAddrKind::V4);route(IpAddrKind::V6);
}fn route(ip_kind: IpAddrKind) {}

使用枚举甚至还有更多优势。进一步考虑一下我们的 IP 地址类型，目前没有一个存储实际 IP 地址数据的方法；只知道它是什么类型的。可以使用结构体来解决这个问题：

#[derive(Debug)]
enum IpAddrKind {V4,V6,
}#[derive(Debug)]
struct IpAddr {kind: IpAddrKind,address: String,
}fn main() {let home = IpAddr {kind: IpAddrKind::V4,address: String::from("127.0.0.1"),};let loopback = IpAddr {kind: IpAddrKind::V6,address: String::from("::1"),};println!("{:?}", home);println!("{:?}", loopback);
}

这里定义了一个有两个字段的结构体 IpAddr：IpAddrKind（之前定义的枚举）类型的 kind字段和 String 类型 address 字段。有这个结构体的两个实例。第一个，home，它的 kind的值是 IpAddrKind::V4 与之相关联的地址数据是 127.0.0.1。第二个实例，loopback，kind的值是 IpAddrKind 的另一个成员，V6，关联的地址是 ::1。使用了一个结构体来将 kind和 address 打包在一起，现在枚举成员就与值相关联了。

还可以使用一种更简洁的方式来表达相同的概念，仅仅使用枚举并将数据直接放进每一个枚举成员而不是将枚举作为结构体的一部分。IpAddr 枚举的新定义表明了 V4 和 V6 成员都关联了 String值：

#[derive(Debug)]
enum IpAddrKind {V4(String),V6(String),
}fn main() {let home = IpAddrKind::V4(String::from("127.0.0.1"));let loopback = IpAddrKind::V6(String::from("::1"));println!("{:?}", home);println!("{:?}", loopback);
}

直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。这里也很容易看出枚举工作的另一个细节：每一个定义的枚举成员的名字也变成了一个构建枚举的实例的函数。也就是说，IpAddr::V4() 是一个获取 String 参数并返回 IpAddr 类型实例的函数调用。作为定义枚举的结果，这些构造函数会自动被定义。

用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果想要将 V4 地址存储为四个 u8 值而 V6 地址仍然表现为一个 String，这就不能使用结构体了。枚举则可以轻易的处理这个情况：

#[derive(Debug)]
enum IpAddrKind {V4(u8, u8, u8, u8),V6(String),
}fn main() {let home = IpAddrKind::V4(127,0,0,1);let loopback = IpAddrKind::V6(String::from("::1"));println!("{:?}", home);println!("{:?}", loopback);
}

这些代码展示了如何用枚举来表示两种类型的 IP 地址。虽然这种做法是有效的，但由于存储和处理 IP 地址在实际开发中非常常见，Rust 的标准库早已为我们提供了一个现成的解决方案。标准库中的 IpAddr 枚举与我们自定义的非常相似，但它更进一步：将每种 IP 类型分别封装在专门的结构体中，从而更清晰地区分不同格式的 IP 地址：

#![allow(unused)]
fn main() {
struct Ipv4Addr {// --snip--
}struct Ipv6Addr {// --snip--
}enum IpAddr {V4(Ipv4Addr),V6(Ipv6Addr),
}
}

这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体。甚至可以包含另一个枚举！另外，标准库中的类型通常并不比你设想出来的要复杂多少。

注意虽然标准库中包含一个 IpAddr 的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。

枚举的成员中可以内嵌多种多样的类型：

enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),
}

这个枚举有四个含有不同类型的成员：

• Quit 没有关联任何数据。
• Move 类似结构体包含命名字段。
• Write 包含单独一个 String。
• ChangeColor 包含三个 i32。

定义一个这样的有关联值的枚举的方式和定义多个不同类型的结构体的方式很相像，除了枚举不使用 struct 关键字以及其所有成员都被组合在一起位于 Message 类型下。如下这些结构体可以包含与之前枚举成员中相同的数据：

struct QuitMessage; // 类单元结构体
struct MoveMessage {x: i32,y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

不过，如果使用不同的结构体，由于它们都有不同的类型，将不能像使用定义的 Message 枚举那样，轻易的定义一个能够处理这些不同类型的结构体的函数，因为枚举是单独一个类型。

结构体和枚举还有另一个相似点：就像可以使用 impl 来为结构体定义方法那样，也可以在枚举上定义方法。这是一个定义于 Message 枚举上的叫做 call 的方法：

#[derive(Debug)]
enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),
}impl Message {fn call(&self) {println!("{:?}", self)}
}fn main() {let m = Message::Write(String::from("hello"));m.call();
}

方法体使用了 self 来获取调用方法的值。这个例子中，创建了一个值为 Message::Write(String::from("hello")) 的变量 m，而且这就是当 m.call() 运行时 call 方法中的 self 的值。

Option 枚举

Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值。

例如，如果请求一个非空列表的第一项，会得到一个值，如果请求一个空的列表，就什么也不会得到。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。

编程语言的设计经常要考虑包含哪些功能，但考虑排除哪些功能也很重要。Rust 并没有很多其他语言中有的空值功能。空值是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。

空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性无处不在，非常容易出现这类错误。

然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值。

问题不在于概念而在于具体的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是 Option<T>，而且它定义于标准库中，如下：

enum Option<T> {None,Some(T),
}

Option<T> 枚举是如此有用以至于它甚至被包含在了 prelude 之中，你不需要将其显式引入作用域。另外，它的成员也是如此，可以不需要 Option:: 前缀来直接使用 Some 和 None。即便如此 Option<T> 也仍是常规的枚举，Some(T) 和 None 仍是 Option<T> 的成员。

<T> 是一个泛型类型参数，目前，只需要知道的就是 <T> 意味着 Option 枚举的 Some 成员可以包含任意类型的数据，同时每一个用于 T 位置的具体类型使得 Option<T> 整体作为不同的类型。这里是一些包含数字类型和字符串类型 Option 值的例子：

fn main() {let some_number = Some(5);let some_string = Some("a string");let absent_number: Option<i32> = None;println!("{:?}", some_number);println!("{:?}", some_string);println!("{:?}", absent_number);
}

some_number 的类型是 Option<i32>。some_char 的类型是 Option<char>，是不同于some_number的类型。因为在 Some 成员中指定了值，Rust 可以推断其类型。对于 absent_number，Rust 需要指定 Option 整体的类型，因为编译器只通过 None 值无法推断出 Some 成员保存的值的类型。这里我们告诉 Rust 希望 absent_number 是 Option<i32> 类型的。

当有一个 Some 值时，就知道存在一个值，而这个值保存在 Some 中。当有个 None 值时，在某种意义上，它跟空值具有相同的意义：并没有一个有效的值。那么，Option<T> 为什么就比空值要好呢？

简而言之，因为 Option<T> 和 T（这里 T 可以是任何类型）是不同的类型，编译器不允许像一个肯定有效的值那样使用 Option<T>。例如，这段代码不能编译，因为它尝试将 Option<i8> 与 i8相加：

fn main() {let x: i8 = 5;let y: Option<i8> = Some(5);let sum = x + y;
}

运行这段代码将会产生错误信息：

error[E0277]: cannot add `Option<i8>` to `i8`--> src/main.rs:46:17|
46 |     let sum = x + y;|                 ^ no implementation for `i8 + Option<i8>`|= help: the trait `Add<Option<i8>>` is not implemented for `i8`= help: the following other types implement trait `Add<Rhs>`:`&i8` implements `Add<i8>``&i8` implements `Add``i8` implements `Add<&i8>``i8` implements `Add`

这意味着 Rust 不知道该如何将 Option<i8> 与 i8 相加，因为它们的类型不同。当在 Rust 中拥有一个像 i8 这样类型的值时，编译器确保它总是有一个有效的值。这样可以自信使用而无需做空值检查。只有当使用 Option<i8>（或者任何用到的类型）的时候需要担心可能没有值，而编译器会确保在使用值之前处理了为空的情况。

换句话说，在对 Option<T> 进行运算之前必须将其转换为 T。通常这能帮助开发者捕获到空值最常见的问题之一：假设某值不为空但实际上为空的情况。

Option 枚举最常见的应用场景就是函数可能返回空值，如下面代码所示：

fn find_user(id: u32) -> Option<String> {if id == 1 {Some("Alice".to_string())} else {None}
}fn main() {if let Some(name) = find_user(1) {println!("User: {}", name);} else {println!("User not found.");}
}

用途： 比如查数据库、查列表、查配置时，找不到返回 None，找到了返回 Some(value)。

控制流运算符 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,}
}fn main() {println!("{}", value_in_cents(Coin::Penny));println!("{}", value_in_cents(Coin::Nickel));println!("{}", value_in_cents(Coin::Dime));println!("{}", value_in_cents(Coin::Quarter));
}

拆开 value_in_cents 函数中的 match 来看。首先，列出 match 关键字后跟一个表达式，在这个例子中是 coin 的值。这看起来非常像 if 所使用的条件表达式，不过这里有一个非常大的区别：对于 if，表达式必须返回一个布尔值，而这里它可以是任何类型的。

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

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

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

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

fn value_in_cents(coin: Coin) -> u8 {match coin {Coin::Penny => {println!("Lucky penny!");1}Coin::Nickel => 5,Coin::Dime => 10,Coin::Quarter => 25,}
}

匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。

1999 年到 2008 年间，美国在 25 美分的硬币的一侧为 50 个州的每一个都印刷了不同的设计。其他的硬币都没有这种区分州的设计，所以只有这些 25 美分硬币有特殊的价值。可以将这些信息加入一个 enum，通过改变 Quarter 成员来包含一个 State 值：

#[derive(Debug)]
enum UsState {Alabama,Alaska,
}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() {let value = value_in_cents(Coin::Quarter(UsState::Alaska));println!("{:?}", value);
}

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

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

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

fn main() {let five = Some(5);let six = plus_one(five);let none = plus_one(None);println!("{:?}, {:?}, {:?}", five, six, none);
}
fn plus_one(x: Option<i32>) -> Option<i32> {match x {None => None,Some(i) => Some(i + 1),}
}

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

fn main() {let five = Some(5);let six = plus_one(five);let none = plus_one(None);println!("{:?}, {:?}, {:?}", five, six, none);
}
fn plus_one(x: Option<i32>) -> Option<i32> {match x {Some(i) => Some(i + 1),}
}

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

error[E0004]: non-exhaustive patterns: `None` not covered--> src/main.rs:8:11|
8   |     match x {|           ^ pattern `None` not covered|
note: `Option<i32>` defined here--> /Users/huangruibang/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/option.rs:572:1|
572 | pub enum Option<T> {| ^^^^^^^^^^^^^^^^^^
...
576 |     None,|     ---- 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|
9   ~         Some(i) => Some(i + 1),
10  ~         None => todo!(),|

Rust 知道没有覆盖所有可能的情况甚至知道哪些模式被忘记了。Rust 中的匹配是穷尽的：必须穷举到最后的可能性来使代码有效。特别的在这个 Option<T> 的例子中，Rust 防止开发者忘记明确的处理 None 的情况，这让开发者免于假设拥有一个实际上为空的值，从而使错误不可能发生。

有时候只需要对特定的值采取特殊操作，其他的值采取默认操作，就可以通过通配模式——将匹配到的默认值绑定为 other 来实现。例如：只在 1、3、5、7 的时候有输出，其它数字都不进行操作：

fn main() {let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];for element in arr {match element {1 => println!("One"),3 => println!("Three"),5 => println!("Five"),7 => println!("Seven"),other => println!("Other"),}}
}

除了用通配模式，还可以用占位符 _ 来实现：

fn main() {let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];for element in arr {match element {1 => println!("One"),3 => println!("Three"),5 => println!("Five"),7 => println!("Seven"),_ => println!("Other"),}}
}

简洁控制流 if let

在数字 1-10 中随机生成一个数，只有生成 6 才会显示 “You win!”，用 match 的代码如下：

use rand::Rng;
fn main() {let number = rand::thread_rng().gen_range(1..=10);println!("{}", number);match number {6 => println!("You win!"),_ => (),}
}

if let 语法以一种不那么冗长的方式结合 if 和 let，来处理只匹配一个模式的值而忽略其他模式的情况：

use rand::Rng;
fn main() {let number = rand::thread_rng().gen_range(1..=10);println!("{}", number);if let 6 = number {println!("You win!");};
}

if let 语法获取通过等号分隔的一个模式和一个表达式。它的工作方式与 match 相同，这里的表达式对应 match 而模式则对应第一个分支。模式不匹配时 if let 块中的代码不会执行。

使用 if let 意味着编写更少代码，更少的缩进和更少的样板代码。然而，这样会失去 match 强制要求的穷尽性检查。match 和 if let 之间的选择依赖特定的环境以及增加简洁度和失去穷尽性检查的权衡取舍。

换句话说，可以认为 if let 是 match 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。

可以在 if let 中包含一个 else。else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else。

生成非 6 的数字显示 “You lose!”：

use rand::Rng;
fn main() {let number = rand::thread_rng().gen_range(1..=10);println!("{}", number);if let 6 = number {println!("You win!");}else { println!("You lose!");}
}

if let–else 是 match 的简化版，类似 if–else，但专门匹配特定模式，更适合只关心一种匹配的情况。