【Rust学习】10_定义枚举

前言

这一章开始我们的rust版本升级为 rustc 1.82.0 (f6e511eec 2024-10-15)

在这一章我们学习 枚举（enumerations），也被称作 enums。枚举允许你通过列举可能的 成员（variants） 来定义一个类型。首先，我们会定义并使用一个枚举来展示它是如何连同数据一起编码信息的。接下来，我们会探索一个特别有用的枚举，叫做 Option，它代表一个值要么是某个值要么什么都不是。然后会讲到在 match 表达式中用模式匹配，针对不同的枚举值编写相应要执行的代码。最后，我们将学习 if let 结构，另一个简洁方便处理代码中枚举的结构。

内容

结构为您提供了一种将相关字段和数据组合在一起的方法，例如具有宽度和高度的矩形，枚举为您提供了一种表示值是一组可能的值之一的方法。例如，我们可能想说矩形是一组可能的形状之一，其中也包括圆形和三角形。为此，Rust允许我们将这些可能性编码为枚举。

定义枚举

让我们看看我们可能想在代码中表达的情况，看看为什么在这种情况下 enum 比structs 有用且更合适。假设我们需要使用 IP 地址。目前，IP 地址使用两个主要标准：IPv4 和 IPv6。因为这些是我们的程序会遇到的 IP 地址的唯一可能性，所以我们可以 枚举 所有可能的值，这就是枚举名称的由来。

任何 IP 地址都可以是 IPv4 或IPv6 地址，但不能同时是两者。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。 IPv4 和 IPv6 地址在基本上仍然是 IP 地址，因此在代码处理适用于任何类型的 IP 地址的情况时，应将它们视为相同类型。

我们可以通过定义 IpAddrKind 枚举并列出 IP 地址的可能类型（V4 和 V6）来在代码中表达此概念。这些是枚举的成员：

enum IpAddrKind {
    V4,
    V6,
}

IpAddrKind 现在是一种自定义数据类型，我们可以在代码中的其他位置使用它。

Enum Values 枚举值

我们可以创建 IpAddrKind 的两个成员的实例，如下所示：

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

请注意，枚举的成员在其标识符下命名空间，我们使用双冒号将两者分隔开。这很有用，因为现在值 IpAddrKind：：V4 和 IpAddrKind：：V6 都属于同一类型：IpAddrKind。例如，我们可以定义一个接受任何 IpAddrKind 的函数：

fn route(ip_kind: IpAddrKind) {}

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

route(IpAddrKind::V4);
route(IpAddrKind::V6);

使使用 enum 还有更多优势。更多地考虑我们的 IP 地址类型，目前我们没有办法存储实际的 IP 地址数据；我们只知道它是什么类型。鉴于你刚刚在第 5 章中学习了结构体，你可能会想用结构体来解决这个问题，如下所示：

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"),
    };
}

在这里，我们定义了一个结构体 IpAddr，它有两个字段：一个 IpAddrKind（我们之前定义的枚举） 类型的 kind 字段和一个 String 类型的 address 字段。我们有这个结构的两个实例。第一个是 home，它的值为 IpAddrKind：：V4 作为其类型，关联的地址数据为 127.0.0.1。第二个实例是 loopback。它具有 IpAddrKind 的另一个成员作为其 kind 值 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类型的实例。由于定义了枚举，我们自动得到了这个构造函数。

使用 enum 而不是 struct 还有另一个好处：每个成员可以具有不同类型和数量的关联数据。IPv4 地址将始终具有四个数字组件，其值介于 0 和 255 之间。如果我们想将 V4 地址存储为 4 个 u8 值，但仍将 V6 地址表示为 1 个 String 值，那么我们将无法使用 struct 来实现。枚举可以轻松处理这种情况：

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"));
}

我们展示了几种不同的方法来定义数据结构来存储 IPV4 和 IPV 6 的 IP 地址。然而，事实证明想要存储 IP 地址并编码它们的种类是如此普遍，以至于标准库有一个我们可以使用的定义！让我们看看标准库是如何定义 IpAddr 的：它具有跟我们定义和使用的一样的枚举和成员，但它以两个不同结构的形式将地址数据嵌入到成员中，每个成员的定义不同：

#![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 类型下。如下这些结构体可以包含与之前枚举成员中相同的数据：

#![allow(unused)]
fn main() {
struct QuitMessage; // 类单元结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体
}

但是，如果我们使用不同的结构体，每个结构体都有自己的类型，我们就不能像上面定义的 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 来获取我们调用该方法的值。在这个例子中，我们创建了一个值为 Message::Write(String::from("hello")) 的变量 m，当 m.call（） 运行时，这个变量 self 将在 call 方法的主体中。

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

Option枚举及其相对于 null 值的优势

本节探讨了 Option 的案例研究，这是标准库定义的另一个枚举。Option 类型对非常常见的情况进行编码，在这种情况下，值可以是某物，也可以为空。

例如，如果您请求非空列表中的第一项，则会得到一个值。如果您请求空列表中的第一项，则不会得到任何内容。用类型系统来表达这个概念意味着编译器可以检查你是否已经处理了你应该处理的所有情况；此功能可以防止其他编程语言中极其常见的 bug。

编程语言设计通常是根据您包含哪些特性来考虑的，但您排除的特性也很重要。Rust没有许多其他语言具有的null特性。Null是一个值，意味着那里没有值。在具有null的语言中，变量总是可以处于两种状态之一：null或not-null。

在 2009 年的演讲“Null References： The Billion Dollar Mistake”中，null 的发明者 Tony Hoare 这样说：

我称之为我十亿美元的错误。那时，我正在设计第一个用于面向对象语言引用的综合类型系统。我的目标是确保所有引用的使用都应该是绝对安全的，并且检查由编译器自动执行。但我无法抗拒放入 null 引用的诱惑，仅仅因为它很容易实现。这导致了无数的错误、漏洞和系统崩溃，在过去 40 年中可能造成了 10 亿美元的痛苦和损害。

null 值的问题在于，如果尝试将 null 值用作非 null 值，则会收到某种错误。由于此 null 或非 null 属性普遍存在，因此很容易出现此类错误。

但是，null 试图表达的概念仍然是一个有用的概念：null 是当前无效或由于某种原因不存在的值。

问题实际上不在于概念，而在于特定的实现。因此，Rust 没有 null，但它确实有一个 enum，它可以编码值存在或不存在的概念。此枚举是 Option<T>，它由标准库定义如下：

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;
}

如果我们运行这段代码，我们会收到如下错误消息：

error[E0277]: cannot add `Option<i8>` to `i8`
   --> src/main.rs:137:17
    |
137 |     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`

很好！实际上，这个错误消息意味着 Rust 不理解如何添加 i8 和 Option<i8>，因为它们是不同的类型。当我们在 Rust 中有一个像 i8 这样的值时，编译器将确保我们始终有一个有效的值。我们可以自信地继续，而无需在使用该值之前检查 null。只有当我们有 Option<i8>（或我们正在处理的任何类型的值）时，我们才需要担心可能没有值，编译器将确保我们在使用该值之前处理这种情况。

换句话说，您必须先将 Option<T> 转换为 T，然后才能使用它执行 T 操作。通常，这有助于捕获 null 最常见的问题之一：假设某些内容实际上不是 null。

除错误地假设非 null 值的风险有助于您对代码更有信心。为了具有可能为 null 的值，您必须通过将该值的类型设为 Option<T> 来显式选择加入。然后，当您使用该值时，您需要显式处理值为 null 的情况。如果值的类型不是 Option<T>，则可以安全地假设该值不为 null。这是 Rust 的一个深思熟虑的设计决策，以限制 null 的普遍性并提高 Rust 代码的安全性。

那么，当您具有 Option<T> 类型的值时，如何从 Some 变体中获取 T 值，以便可以使用该值呢？Option<T> 枚举具有大量在各种情况下都有用的方法;您可以在其文档中查看它们。熟悉 Option<T> 的方法在你的 Rust 之旅中将非常有用。

通常，为了使用 Option<T> 值，您需要具有能够处理每个变体的代码。您需要一些仅在您具有 Some（T） 值时运行的代码，并且允许此代码使用内部 T。您希望其他代码仅在您有 None 值且该代码没有可用的 T 值时运行。match 表达式是一种控制流结构，当与枚举一起使用时，它只执行此操作：它将根据它所具有的枚举的变体运行不同的代码，并且该代码可以使用匹配值中的数据。