Rust-枚举

本文介绍 Rust 枚举（enumerations ），也被称作 enums。

枚举允许你通过列举可能的成员（variants）来定义一个类型。

首先，我们会定义并使用一个枚举来展示它是如何连同数据一起编码信息的。接下来，我们会探索一个特别有用的枚举，叫做 Option，它代表一个值要么是某个值要么什么都不是。

枚举是一个很多语言都有的功能，不过不同语言中其功能各不相同。

1. 定义枚举

枚举(enum 或 enumeration)允许你通过列举可能的成员来定义一个枚举类型，例如扑克牌花色：

rust 复制代码

enum PokerSuit {
  Clubs,
  Spades,
  Diamonds,
  Hearts,
}
//分别代表：梅花、黑桃、方块、红桃

任何一张扑克，它的花色肯定会落在这四种花色中，而且也只会落在其中一个花色上。这种特性非常适合枚举的使用，因为枚举值只可能是其中某一个成员。抽象来看，四种花色尽管是不同的花色，但是它们都是扑克花色这个概念，因此当某个函数处理扑克花色时，可以把它们当作相同的类型进行传参。

可能你会注意到，我们对上面段落中的 枚举类型 和 枚举值 进行了重点标注，这是因为对于新人来说容易混淆相应的概念，总而言之： 枚举类型是一个类型，它会包含所有可能的枚举成员，而枚举值是该类型中的具体某个成员的实例。

2. 枚举值

现在来创建 PokerSuit 枚举类型的两个成员实例：

rust 复制代码

let heart = PokerSuit::Hearts;     //红桃
let diamond = PokerSuit::Diamonds; //方块

我们通过 :: 操作符来访问 PokerSuit 下的具体成员，从代码可以清晰看出，heart 和 diamond 都是 PokerSuit 枚举类型的，接着可以定义一个函数来使用它们：

rust 复制代码

fn main() {
    let heart = PokerSuit::Hearts;
    let diamond = PokerSuit::Diamonds;

    print_suit(heart);
    print_suit(diamond);
}

fn print_suit(card: PokerSuit) {
    // 需要在定义 enum PokerSuit 的上面添加上 #[derive(Debug)]，才能通过 {:?} 进行打印
    println!("{:?}",card);
}

print_suit 函数的参数类型是 PokerSuit，因此我们可以把heart 和 diamond 传给它，虽然 heart 是基于 PokerSuit 下的 Hearts 成员实例化的，但是它是货真价实的 PokerSuit 枚举类型。

接下来，我们想让扑克牌变得更加实用，那么需要给每张牌赋予一个值：A(1)-K(13)，这样再加上花色，就是一张真实的扑克牌了，例如红心 A。

目前来说，枚举值还不能带有值，因此先用结构体来实现：

rust 复制代码

enum PokerSuit {
    Clubs,
    Spades,
    Diamonds,
    Hearts,
}

struct PokerCard {
    suit: PokerSuit,
    value: u8
}

fn main() {
   //梅花1
   let c1 = PokerCard {
       suit: PokerSuit::Clubs,
       value: 1,
   };
   //方块Q
   let c2 = PokerCard {
       suit: PokerSuit::Diamonds,
       value: 12,
   };
}

这段代码很好的完成了它的使命，通过结构体 PokerCard 来代表一张牌，结构体的 suit 字段表示牌的花色，类型是 PokerSuit 枚举类型，value 字段代表扑克牌的数值。

可以吗？可以！好吗？说实话，不咋地，因为还有简洁得多的方式来实现：

rust 复制代码

enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

fn main() {
   let c1 = PokerCard::Spades(5);
   let c2 = PokerCard::Diamonds(13);
}

直接将数据信息关联到枚举成员上，省去近一半的代码，这种实现是不是更优雅？

不仅如此，同一个枚举类型下的不同成员还能持有不同的数据类型，例如让某些花色打印 1-13 的字样，另外的花色打印上 A-K 的字样：

rust 复制代码

enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(char),
    Hearts(char),
}

fn main() {
   let c1 = PokerCard::Spades(5);
   let c2 = PokerCard::Diamonds('A');
}

这种写法的优点是不需要额外使用 struct 去存储数据，且每个枚举的变体都可以拥有不同的数据类型以及关联的数据量。

例如一个关于描述IP地址的枚举代码：

rust 复制代码

enum IpAddr{
    ipv4(u8,u8,u8,u8),
    ipv6(String)
}

fn main() {
    let home = IpAddr::ipv4(127, 0, 0, 1);
    let loopback = IpAddr::ipv6("::1".to_string());
}

再来看一个成员中内嵌了多种多样类型的枚举代码：

rust 复制代码

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

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move{x:1,y:1};
    let m3 = Message::ChangeColor(255,255,0);
}

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

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

3. 枚举的方法

枚举也可以像结构体那样，可以使用 impl 来定义方法。

这是我们在 Message 枚举上定义了一个叫做 call 的方法：

rust 复制代码

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

    impl Message {
        fn call(&self) {
            // 在这里定义方法体
        }
    }

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

4. Option枚举

在其它编程语言中，往往都有一个 null 关键字，该关键字用于表明一个变量当前的值为空（不是零值，例如整型的零值是 0），也就是不存在值。当我们对这些 null 进行操作时，例如调用一个方法，就会直接抛出null 异常 ，导致程序的崩溃，因此我们在编程时需要格外的小心去处理这些 null 空值。

Rust 在设计时吸取了众多由于"null"引发问题的教训，决定抛弃 null，而改为使用 Option 枚举变量来表述这种结果。

实际上就是通过一个"可以编码存在或不存在概念的枚举 Option"，来实现出类似于"null"的效果，而且它定义于标准库中，如下:

rust 复制代码

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

Option 枚举包含两个成员，一个成员表示含有值：Some(T), 另一个表示没有值：None。

其中 T 是泛型参数，Some(T)表示该枚举成员的数据类型是 T，换句话说，Some 可以包含任何类型的数据。

Option<T> 枚举因为其自身的特殊性和用途，Rust支持我们无需将其显式地引入作用域，直接使用即可。它的成员 Some 和 None 也是如此，无需使用 Option:: 前缀就可直接使用 Some 和 None。

未来，当我们看到 Some(T) 和 None ，虽然没有 Option:: 的身影，但也知道它们是 Option 枚举中的两个成员。

再来看以下代码：

rust 复制代码

let some_number = Some(5);
let some_string = Some("a string");

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>(Option<T>) 与 i8(T) 直接相加：

rust 复制代码

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

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

rust 复制代码

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

很好！事实上，错误信息意味着 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 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。

这里先简单看一下 match 的大致模样，在下一篇模式匹配中，我们会详细讲解：

rust 复制代码

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);

plus_one 通过 match 来处理不同 Option 的情况。

‍