定义枚举
结构体让你能够将相关的字段和数据组合在一起，例如一个带有 width 和 height 的 Rectangle，而枚举则让你能够表达一个值是可能值集合中的一个。例如，我们可能想说 Rectangle 是一个可能的形状集合中的一个，这个集合还包括 Circle 和 Triangle。为了做到这一点，Rust 允许我们将这些可能性编码为一个枚举。
让我们看看一个我们可能想在代码中表达的情况，并了解为什么枚举在这种情况下比结构体更有用和更合适。假设我们需要处理 IP 地址。目前，IP 地址使用了两个主要的标准：版本四和版本六。因为这是我们的程序将遇到的 IP 地址的唯二可能性，我们可以枚举所有可能的变体，这就是枚举名称的由来。
任何 IP 地址可以是版本四地址，也可以是版本六地址，但不能同时是两者。IP 地址的这个特性使得枚举数据结构很适用，因为一个枚举值只能是它的变体之一。版本四和版本六地址在根本上仍然是 IP 地址，因此当代码处理适用于任何类型 IP 地址的情况时，它们应该被视为同一类型。
我们可以通过定义一个 IpAddrKind 枚举并列出 IP 地址可能存在的类型，即 V4 和 V6，来在代码中表达这个概念。这些是枚举的变体
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) {}
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) {}
请注意，枚举的变体在其标识符下命名，我们使用双冒号分隔两者。这很有用，因为现在两个值 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) {}
我们可以使用任何一个变体来调用此函数
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 地址数据；我们只知道它是什么类型。鉴于你刚刚在第 5 章学习了结构体，你可能会尝试使用结构体来解决这个问题，如列表 6-1 所示。
fn main() { enum IpAddrKind { V4, V6, } struct IpAddr { kind: IpAddrKind, address: String, } let home = IpAddr { kind: IpAddrKind::V4, address: String::from("127.0.0.1"), }; let loopback = IpAddr { kind: IpAddrKind::V6, address: String::from("::1"), }; }
列表 6-1：使用 struct 存储 IP 地址的数据和 IpAddrKind 变体
在这里，我们定义了一个具有两个字段的结构体 IpAddr：一个类型为 IpAddrKind（我们之前定义的枚举）的 kind 字段和一个类型为 String 的 address 字段。我们有两个该结构体的实例。第一个是 home，它的 kind 值为 IpAddrKind::V4，关联的地址数据为 127.0.0.1。第二个实例是 loopback。它的 kind 值为 IpAddrKind 的另一个变体 V6，关联的地址为 ::1。我们使用结构体将 kind 和 address 值捆绑在一起，因此现在变体与值关联。
但是，仅使用枚举来表示相同的概念会更简洁：我们可以将数据直接放入每个枚举变体中，而不是在结构体内部使用枚举。 IpAddr 枚举的这个新定义表明 V4 和 V6 变体都将具有关联的 String 值
fn main() { enum IpAddr { V4(String), V6(String), } let home = IpAddr::V4(String::from("127.0.0.1")); let loopback = IpAddr::V6(String::from("::1")); }
我们将数据直接附加到枚举的每个变体，因此不需要额外的结构体。在这里，也更容易看到枚举工作的另一个细节：我们定义的每个枚举变体的名称也成为一个构造枚举实例的函数。也就是说，IpAddr::V4() 是一个函数调用，它接收一个 String 参数并返回一个 IpAddr 类型的实例。我们自动获得这个构造函数作为定义枚举的结果。
使用枚举而不是结构体还有另一个优势：每个变体可以具有不同类型和数量的关联数据。版本四的 IP 地址始终具有四个数值组件，其值介于 0 到 255 之间。如果我们想将 V4 地址存储为四个 u8 值，但仍然将 V6 地址表达为一个 String 值，我们就无法使用结构体做到这一点。枚举可以轻松处理这种情况
fn main() { enum IpAddr { V4(u8, u8, u8, u8), V6(String), } let home = IpAddr::V4(127, 0, 0, 1); let loopback = IpAddr::V6(String::from("::1")); }
我们已经展示了几种不同的方法来定义数据结构以存储版本四和版本六的 IP 地址。但是，事实证明，想要存储 IP 地址并编码它们是什么类型是如此普遍，以至于 标准库有一个我们可以使用的定义！让我们看看标准库如何定义 IpAddr：它具有我们定义和使用的确切枚举和变体，但它以两种不同结构体的形式将地址数据嵌入到变体中，这两种结构体对于每个变体的定义都不同
#![allow(unused)] fn main() { struct Ipv4Addr { // --snip-- } struct Ipv6Addr { // --snip-- } enum IpAddr { V4(Ipv4Addr), V6(Ipv6Addr), } }
此代码说明你可以将任何类型的数据放入枚举变体中：例如字符串、数字类型或结构体。你甚至可以包含另一个枚举！此外，标准库类型通常并不比你可能想出的类型复杂多少。
请注意，即使标准库包含 IpAddr 的定义，我们仍然可以创建和使用我们自己的定义而不会发生冲突，因为我们尚未将标准库的定义引入我们的作用域。我们将在第 7 章中讨论更多关于将类型引入作用域的内容。
让我们看看列表 6-2 中另一个枚举的示例：它的变体中嵌入了各种各样的类型。
enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } fn main() {}
列表 6-2：一个 Message 枚举，其变体各自存储不同数量和类型的值
此枚举具有四种具有不同类型的变体
Quit没有关联任何数据。Move具有命名字段，就像结构体一样。Write包含一个String。ChangeColor包含三个i32值。
定义具有列表 6-2 中变体的枚举类似于定义不同类型的结构体定义，但枚举不使用 struct 关键字，并且所有变体都分组在 Message 类型下。以下结构体可以容纳前面枚举变体所容纳的相同数据
struct QuitMessage; // unit struct struct MoveMessage { x: i32, y: i32, } struct WriteMessage(String); // tuple struct struct ChangeColorMessage(i32, i32, i32); // tuple struct fn main() {}
但是，如果我们使用不同的结构体，每个结构体都有自己的类型，我们就不能像使用列表 6-2 中定义的 Message 枚举（它是一种单一类型）那样轻松地定义一个函数来接收任何这些类型的消息。
枚举和结构体之间还有一个相似之处：正如我们能够使用 impl 在结构体上定义方法一样，我们也能够在枚举上定义方法。以下是一个名为 call 的方法，我们可以在 Message 枚举上定义
fn main() { enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32), } impl Message { fn call(&self) { // method body would be defined here } } let m = Message::Write(String::from("hello")); m.call(); }
方法的主体将使用 self 来获取我们调用该方法的value。在这个例子中，我们创建了一个变量 m，它的值为 Message::Write(String::from("hello"))，这就是在 m.call() 运行时 call 方法主体中的 self。
让我们看看标准库中另一个非常常见且有用的枚举：Option。
Option 枚举及其相对于空值的优势
本节探讨 Option 的案例研究，它是标准库定义的另一个枚举。 Option 类型编码了一种非常常见的情况，即一个值可以是某个东西，也可以什么都不是。
例如，如果你请求非空列表中的第一项，你将获得一个值。如果你请求空列表中的第一项，你将一无所获。用类型系统来表达这个概念意味着编译器可以检查你是否处理了所有应该处理的情况；此功能可以防止其他编程语言中极其常见的错误。
编程语言的设计通常从你包含哪些功能来考虑，但是你排除的功能也很重要。Rust 没有许多其他语言都具有的空功能。Null 是一个值，表示那里没有值。在具有空的语言中，变量始终可以处于两种状态之一：空或非空。
在 2009 年的演讲“空引用：十亿美元的错误”中，空的创造者托尼·霍尔这样说道
我称之为我十亿美元的错误。当时，我正在为面向对象的语言设计第一个全面的引用类型系统。我的目标是确保所有引用的使用都绝对安全，并由编译器自动执行检查。但是我无法抗拒放入空引用的诱惑，因为它实现起来太容易了。这导致了无数的错误、漏洞和系统崩溃，在过去四十年中可能造成了十亿美元的痛苦和损失。
空值的问题在于，如果你尝试将空值用作非空值，你将得到某种错误。因为这种空或非空的属性很普遍，所以很容易犯这种错误。
但是，空值试图表达的概念仍然是有用的：空值是一个由于某种原因当前无效或不存在的值。
问题实际上不是概念，而是特定的实现。因此，Rust 没有空值，但它确实有一个枚举可以编码一个值存在或不存在的概念。这个枚举是 Option<T>，它由标准库定义如下
#![allow(unused)] fn main() { enum Option<T> { None, Some(T), } }
Option<T> 枚举非常有用，甚至被包含在 prelude 中；你不需要显式地将其引入作用域。它的变体也包含在 prelude 中：你可以直接使用 Some 和 None，而无需 Option:: 前缀。Option<T> 枚举仍然只是一个普通的枚举，Some(T) 和 None 仍然是 Option<T> 类型的变体。
<T> 语法是我们尚未讨论过的 Rust 功能。它是一个泛型类型参数，我们将在第 10 章中更详细地介绍泛型。现在，你只需要知道 <T> 表示 Option 枚举的 Some 变体可以保存任何类型的一段数据，并且每个用作 T 替代的具体类型都会使整个 Option<T> 类型成为不同的类型。以下是一些使用 Option 值来保存数字类型和字符串类型的示例。
fn main() { let some_number = Some(5); let some_char = Some('e'); let absent_number: Option<i32> = None; }
some_number 的类型是 Option<i32>。some_char 的类型是 Option<char>，这是一个不同的类型。Rust 可以推断这些类型，因为我们在 Some 变体内部指定了一个值。对于 absent_number，Rust 要求我们注解整个 Option 类型：编译器无法仅通过查看 None 值来推断相应的 Some 变体将保存的类型。在这里，我们告诉 Rust 我们希望 absent_number 的类型为 Option<i32>。
当我们有一个 Some 值时，我们知道一个值存在，并且该值保存在 Some 中。当我们有一个 None 值时，在某种意义上，它的含义与 null 相同：我们没有一个有效的值。那么，为什么拥有 Option<T> 比拥有 null 更好呢？
简而言之，因为 Option<T> 和 T（其中 T 可以是任何类型）是不同的类型，编译器不允许我们将 Option<T> 值当作肯定是有效的值来使用。例如，以下代码将无法编译，因为它试图将 i8 添加到 Option<i8>
fn main() {
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y;
}如果我们运行此代码，我们将收到如下错误消息
$ cargo run
Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
--> src/main.rs:5:17
|
5 | 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>`:
`&'a i8` implements `Add<i8>`
`&i8` implements `Add<&i8>`
`i8` implements `Add<&i8>`
`i8` implements `Add`
For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error
太棒了！实际上，此错误消息表示 Rust 不理解如何将 i8 和 Option<i8> 相加，因为它们是不同的类型。当我们在 Rust 中拥有像 i8 这样的类型的值时，编译器将确保我们始终拥有有效的值。我们可以放心地继续操作，而无需在使用该值之前检查 null。只有当我们拥有 Option<i8>（或我们正在使用的任何类型的值）时，我们才需要担心可能没有值的情况，并且编译器将确保我们在使用该值之前处理这种情况。
换句话说，你必须先将 Option<T> 转换为 T，然后才能对其执行 T 操作。通常，这有助于捕获 null 最常见的问题之一：假设某事物不是 null，而它实际上是 null。
消除错误假设非 null 值的风险有助于你对自己的代码更有信心。为了拥有一个可能为 null 的值，你必须通过将该值的类型设置为 Option<T> 来显式选择。然后，当你使用该值时，你需要显式处理该值为空的情况。在值具有不是 Option<T> 的类型的所有地方，你 *可以* 安全地假设该值不是 null。这是 Rust 的一个深思熟虑的设计决策，旨在限制 null 的普遍性并提高 Rust 代码的安全性。
那么，当你拥有 Option<T> 类型的值时，如何从 Some 变体中获取 T 值以便可以使用该值呢？ Option<T> 枚举具有大量在各种情况下都有用的方法；你可以在 其文档 中查看它们。熟悉 Option<T> 上的方法将对你的 Rust 之旅非常有用。
一般来说，为了使用 Option<T> 值，你希望拥有能够处理每个变体的代码。你希望某些代码仅在你有 Some(T) 值时运行，并且该代码允许使用内部 T。你希望某些其他代码仅在你具有 None 值时运行，并且该代码没有可用的 T 值。match 表达式是一种控制流结构，当与枚举一起使用时，它可以做到这一点：它将根据它拥有的枚举的哪个变体运行不同的代码，并且该代码可以使用匹配值中的数据。