定义枚举

ch06-01-defining-an-enum.md


commit 5544b998ff426aca7d1eaf248a1d9340df5ab9e7

让我们看看一个需要诉诸于代码的场景，来考虑为何此时使用枚举更为合适且实用。假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的所有可能的 IP 地址类型：所以可以 枚举 出所有可能的值，这也正是此枚举名字的由来。

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

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

  1. enum IpAddrKind {
  2.     V4,
  3.     V6,
  4. }

现在 IpAddrKind 就是一个可以在代码中使用的自定义类型了。

枚举值

可以像这样创建 IpAddrKind 两个不同成员的实例：

  1. # enum IpAddrKind {
  2. #     V4,
  3. #     V6,
  4. # }
  5. #
  6. let four = IpAddrKind::V4;
  7. let six = IpAddrKind::V6;

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

  1. # enum IpAddrKind {
  2. #     V4,
  3. #     V6,
  4. # }
  5. #
  6. fn route(ip_type: IpAddrKind) { }

现在可以使用任一成员来调用这个函数：

  1. # enum IpAddrKind {
  2. #     V4,
  3. #     V6,
  4. # }
  5. #
  6. # fn route(ip_type: IpAddrKind) { }
  7. #
  8. route(IpAddrKind::V4);
  9. route(IpAddrKind::V6);

使用枚举甚至还有更多优势。进一步考虑一下我们的 IP 地址类型，目前没有一个储存实际 IP 地址 数据 的方法；只知道它是什么 类型 的。考虑到已经在第五章学习过结构体了，你可能会像示例 6-1 那样处理这个问题：

  1. enum IpAddrKind {
  2.     V4,
  3.     V6,
  4. }
  6. struct IpAddr {
  7.     kind: IpAddrKind,
  8.     address: String,
  9. }
  11. let home = IpAddr {
  12.     kind: IpAddrKind::V4,
  13.     address: String::from("127.0.0.1"),
  14. };
  16. let loopback = IpAddr {
  17.     kind: IpAddrKind::V6,
  18.     address: String::from("::1"),
  19. };

示例 6-1：将 IP 地址的数据和 IpAddrKind 成员储存在一个 struct 中

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

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

  1. enum IpAddr {
  2.     V4(String),
  3.     V6(String),
  4. }
  6. let home = IpAddr::V4(String::from("127.0.0.1"));
  8. let loopback = IpAddr::V6(String::from("::1"));

我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。

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

  1. enum IpAddr {
  2.     V4(u8, u8, u8, u8),
  3.     V6(String),
  4. }
  6. let home = IpAddr::V4(127, 0, 0, 1);
  8. let loopback = IpAddr::V6(String::from("::1"));

这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了以致标准库提供了一个开箱即用的定义！让我们看看标准库是如何定义 IpAddr 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的：

  1. struct Ipv4Addr {
  2.     // details elided
  3. }
  5. struct Ipv6Addr {
  6.     // details elided
  7. }
  9. enum IpAddr {
  10.     V4(Ipv4Addr),
  11.     V6(Ipv6Addr),
  12. }

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

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

来看看示例 6-2 中的另一个枚举的例子：它的成员中内嵌了多种多样的类型：

  1. enum Message {
  2.     Quit,
  3.     Move { x: i32, y: i32 },
  4.     Write(String),
  5.     ChangeColor(i32, i32, i32),
  6. }

示例 6-2：一个 Message 枚举，其每个成员都储存了不同数量和类型的值

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

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

定义一个像示例 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用 struct 关键字并且所有成员都被组合在一起位于 Message 下之外。如下这些结构体可以包含与之前枚举成员中相同的数据：

  1. struct QuitMessage; // unit struct
  2. struct MoveMessage {
  3.     x: i32,
  4.     y: i32,
  5. }
  6. struct WriteMessage(String); // tuple struct
  7. struct ChangeColorMessage(i32, i32, i32); // tuple struct

不过如果我们使用不同的结构体，它们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用示例 6-2 中定义的 Message 枚举那样，因为它们是一个类型的。

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

  1. # enum Message {
  2. #     Quit,
  3. #     Move { x: i32, y: i32 },
  4. #     Write(String),
  5. #     ChangeColor(i32, i32, i32),
  6. # }
  7. #
  8. impl Message {
  9.     fn call(&self) {
  10.         // method body would be defined here
  11.     }
  12. }
  14. let m = Message::Write(String::from("hello"));
  15. m.call();

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

让我们看看标准库中的另一个非常常见且实用的枚举：Option。

Option 枚举和其相对于空值的优势

在之前的部分，我们看到了 IpAddr 枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。接下来我们分析一个 Option 的案例，Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么是某个值要么什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。

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

在 “Null References: The Billion Dollar Mistake” 中，Tony Hoare，null 的发明者，曾经说到：

I call it my billion-dollar mistake. At that time, I was designing the first
comprehensive type system for references in an object-oriented language. My
goal was to ensure that all use of references should be absolutely safe, with
checking performed automatically by the compiler. But I couldn’t resist the
temptation to put in a null reference, simply because it was so easy to
implement. This has led to innumerable errors, vulnerabilities, and system
crashes, which have probably caused a billion dollars of pain and damage in
the last forty years.

我称之为我十亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抵抗住引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数十亿美元的苦痛和伤害。

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

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

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

  1. enum Option<T> {
  2.     Some(T),
  3.     None,
  4. }

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

<T> 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是 <T> 意味着 Option 枚举的 Some 成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型 Option 值的例子：

  1. let some_number = Some(5);
  2. let some_string = Some("a string");
  4. let absent_number: Option<i32> = None;

如果使用 None 而不是 Some，需要告诉 Rust Option<T> 是什么类型的，因为编译器只通过 None 值无法推断出 Some 变量保留的值的类型。

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

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

  1. let x: i8 = 5;
  2. let y: Option<i8> = Some(5);
  4. let sum = x + y;

如果运行这些代码，将得到类似这样的错误信息：

  1. error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is
  2. not satisfied
  3.  -->
  4.   |
  5. 5 |     let sum = x + y;
  6.   |                 ^ no implementation for `i8 + std::option::Option<i8>`
  7.   |

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

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

无需担心错过存在非空值的假设让我们对代码更加有信心，为了拥有一个可能为空的值，必须显式的将其放入对应类型的 Option<T> 中。接着，当使用这个值时，必须明确的处理值为空的情况。任何地方一个值不是 Option<T> 类型的话，可以 安全的假设它的值不为空。这是 Rust 的一个有意为之的设计选择，来限制空值的泛滥和增加 Rust 代码的安全性。

那么当有一个 Option<T> 的值时，如何从 Some 成员中取出 T 的值来使用它呢？Option<T> 枚举拥有大量用于各种情况的方法：你可以查看相关代码。熟悉 Option<T> 的方法将对你的 Rust 之旅提供巨大的帮助。

总的来说，为了使用 Option<T> 值，需要编写处理每个成员的代码。我们想要一些代码只当拥有 Some(T) 值时运行，这些代码允许使用其中的 T。也希望一些代码在 None 值时运行，这些代码并没有一个可用的 T 值。match 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。