【Rust】笔记：枚举

定义

结构体给予了开发者将字段和数据聚合在一起的方法，而枚举给予你将一个值称为一个集合之一的方法。

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

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

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

enum IPAddrKind {
    v4,
    v6,
}

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

枚举值

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

let four = IPAddrKind::v4;
let six = IPAddrKind::v6;

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

fn route(kind:IPAddrKind) {}

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

route(IPAddrKind::v4);
route(IPAddrKind::v6);

使用枚举还有更多优势，如果按照 Rust 结构体的方式，我们想要储存一个 IP 地址，需要使用如下的代码:

enum IPAddrKind {
    v4,
    v6,
}

struct IPAddr {
    kind: IPAddrKind,
    address: String,
}

let localhost_v4 = IPAddr {
    kind: IPAddrKind::v4,
    address: String::from("127.0.0.1"),
};

let localhost_v6 = IPAddr {
    kind: IPAddrKind::v6,
    address: String::from("::1"),
}

除了使用以上的代码来实现这个功能，我们还可以使用更简洁的方式来表达相同的概念：仅仅使用枚举并将数据放进每一个枚举成员而不是将枚举作为结构体的一部分：

enum IPAddr {
    v4(string),
    v6(string),
}

let localhost_v4 = IPAddr::v4(String::from("127.0.0.1"));
let localhost_v6 = IPAddr::v6(String::from("::1"));

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

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

enum IPAddr {
    v4(u8, u8, u8, u8),
    v6(String),
}

let localhost_v4 = IPAddr::v4(127, 0, 0, 1);
let localhost_v6 = IPAddr::v6(String::from("::1"));

这些代码展示了使用枚举来存储两种不同IP地址的集中可能的选择，然而，事实证明存储和编码IP地址实在太常见了以致标准库提供了一个开箱即用的定义：

struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

这些代码展示了可以将任意类型的数据放入成员变量中，例如字符串、数字类型或者结构体。甚至可以包含另一个枚举。

我们再看另一个枚举的例子：

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

这个俄媒巨有四个含有不同类型的成员：

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

结构体和枚举还有另一个相似点：可以使用 impl 再枚举上定义方法，下面是一个定义 call 的方法：

impl Message {
    fn call(&self) {
        // do something
    }
}

let m = Message::Write(String::from("Hello"));
m.call();

Option 枚举

这个部分会分析一个 Option 的案例，Option 是标准库定义的另一个枚举，Option 类型应用官方应为它编码了一个非常普通的场景，即一个值要么有值，要么没值。

变成愿意谈的设计经常要考虑包含哪些功能，但是考虑到排除哪些共呢个也很重要，Rust 并没有很多其他语言有的空值功能。空值（Null）是一个值，它代表没有值。在有控制的语言中，变量总是这两种状态之一：空值和非空值。

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

然而，空值表达式的概念仍然是有意义的，空值是一个应为某些元婴目前无效或缺失的值，问题不在于概念而在于具体的实现，因此Rust并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举，这个枚举是 Option<T>，而且它定义于标准库中，如下：

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

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

<T>是一个泛型参数，意味着 Option 枚举的 Some 成员可以包含任意类型的数据，同时每一个用于 T 位置的具体类型使得 Option<T> 整体作为不同的类型：

let some_number = Some(5); // Option<i32>
let some_char = Some('e'); // Option<char>

let absent_number : Option<i32> = None;

因为我们在 some_number 和 some_char 的 some 成员中指定了值，所以 Rust 可以借此推断其类型，对于 absent_number, Rust 无法根据 None 值推断出 Some 成员保存的值的类型，这里我们告诉 Rust 希望 absent_number 是 Option<i32> 类型的。

当有一个 some 值时，我们就知道存在一个值，而这个值保存在 Some 中。当有个 None 值时，在某种意义上，它跟空值具有相同的意义：我们并没有一个有效的值。那么，为什么 Option<T> 要比空值更好呢？因为编译器不允许像一个肯定有效的值那样使用 Option<T>，例如，这段代码不能编译，因为它尝试将 Option<i8> 与 i8 相加：

// !编译不过
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 f32 as Add<f32>>
            <&'a f64 as Add<f64>>
            <&'a i128 as Add<i128>>
            <&'a i16 as Add<i16>>
            <&'a i32 as Add<i32>>
            <&'a i64 as Add<i64>>
            <&'a i8 as Add<i8>>
            <&'a isize as Add<isize>>
          and 48 others

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` due to previous error

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

换句话说，在对 Option<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 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。

笔记：Rust 使用 Option 来处理空值比直接使用空值更好的地方是因为：Option 无法直接作为值直接使用，因此开发者在编写代码的时候无需担心使用的变量是否没有值，编译器会帮你解决这一切的问题。