定义枚举 -- Rust教程|Rust中文文档|Rust编程|Rust官方文档

定义枚举

Where 结构为您提供了一种将相关字段和数据分组在一起的方法，例如 a 替换为其 and ，枚举为您提供了一种表示 a 的方式 value 是一组可能的值之一。例如，我们可能想说这是一组可能的形状之一，其中还包括和。为此，Rust 允许我们将这些可能性编码为枚举。RectanglewidthheightRectangleCircleTriangle

让我们看看我们可能想在代码中表达的情况，看看为什么 enum 在这种情况下，比结构更有用且更合适。说我们需要工作替换为 IP 地址。目前，IP 地址使用两个主要标准：版本 4 和版本 6。因为这些是我们的程序会遇到的 IP 地址，我们可以列举所有可能的 variants，这就是 enumeration 得名的地方。

任何 IP 地址都可以是版本 4 或版本 6 地址，但不能是版本 6 地址两者同时进行。IP 地址的该属性使枚举数据结构的适当性，因为 enum 值只能是其变体之一。版本 4 和版本 6 地址从根本上仍然是 IP 地址 addresses 的 URL，因此在代码处理时，它们应该被视为相同的类型适用于任何类型的 IP 地址的情况。

我们可以通过定义一个枚举和列出 IP 地址的可能类型，以及。这些是枚举的变体：IpAddrKindV4V6

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) {}

请注意，枚举的变体在其标识符下命名空间，并且我们使用双冒号分隔两者。这很有用，因为现在值和都属于同一类型：。我们然后，例如，可以定义一个采用 any 的函数：IpAddrKind::V4IpAddrKind::V6IpAddrKindIpAddrKind

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) {}

使用 enum 还有更多优势。更多地考虑我们的 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：存储 data 和 IpAddrKind 的使用结构体的 IP 地址

在这里，我们定义了一个具有两个字段的结构体：一个的类型（我们之前定义的枚举）和一个字段的类型。我们有这个结构的两个实例。首先是，并且它的值为 with associated address 的数据。第二个实例是。它有另一个的 variant 作为其值，并具有与之关联的地址。我们使用了一个结构体将 and 值捆绑在一起，所以现在 variant 与 value 相关联。IpAddrkindIpAddrKindaddressStringhomeIpAddrKind::V4kind127.0.0.1loopbackIpAddrKindkindV6::1kindaddress

但是，仅使用 enum 表示相同的概念更简洁：我们可以将数据直接放入每个枚举中，而不是在结构体中放置枚举变体。枚举的这个新定义表明 and variants 都将具有关联的值：IpAddrV4V6String

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

我们直接将数据附加到枚举的每个变体，因此不需要 extra 结构体。在这里，也更容易看到枚举如何工作的另一个细节：我们定义的每个枚举变体的名称也成为一个函数，该函数构造枚举的实例。也就是说，是一个函数调用它接受一个参数并返回该类型的实例。我们自动获取此构造函数，该函数定义为定义 enum 中。IpAddr::V4()StringIpAddr

使用 enum 而不是 struct 还有另一个好处：每个变体可以具有不同类型和数量的关联数据。版本 4 IP addresses 将始终具有四个数字部分，这些部分将具有 Value 介于 0 和 255 之间。如果我们想将地址存储为四个值，但仍然将 addresses 表示为一个值，则我们无法使用一个 struct.枚举可以轻松处理这种情况：V4u8V6String

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

我们展示了几种不同的方法来定义数据结构来存储版本 4 个和版本 6 个 IP 地址。然而，事实证明，想要存储 IP 地址并编码它们的类型是如此常见，以至于标准 library 有一个我们可以使用的定义！让我们看看如何标准库定义：它具有确切的枚举和变体我们已经定义并使用了，但它将地址数据嵌入到两个不同结构体的形式，每个结构体的定义方式不同变体：IpAddr

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

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

此代码说明了您可以将任何类型的数据放入 enum 变体中：例如，字符串、数字类型或结构。您甚至可以添加另一个 enum！此外，标准库类型通常不会比你可能会想出什么。

请注意，即使标准库包含的定义，我们仍然可以创建和使用我们自己的定义而不会发生冲突，因为我们尚未将标准库的定义引入我们的范围。我们再谈有关将类型引入范围的更多信息，请参见第 7 章。IpAddr

让我们看看示例 6-2 中的另一个枚举示例：这个实例有一个 wide 其变体中嵌入的各种类型的

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

fn main() {}

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

此枚举有四种不同类型的变体：

Quit根本没有与之关联的数据。
Move具有命名字段，就像结构体一样。
Write包括单个 .String
ChangeColor包括 3 个值。i32

使用示例 6-2 中的变体定义枚举类似于定义不同类型的结构体定义，但 enum 不使用关键字，并且所有变体都归类到该类型下。以下结构可以保存与前面的枚举相同的数据 variants 成立：structMessage

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 中定义的 enum，它是一个单一类型。Message

枚举和结构之间还有一个相似之处：就像我们能够使用定义结构体上的方法，我们还能够在上定义方法枚举。下面是一个名为的方法，我们可以在枚举上定义它：implcallMessage

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

该方法的主体将用于获取我们调用 method 打开。在此示例中，我们创建了一个值为 . 的变量，该变量将位于 method 的 body 来运行。selfmMessage::Write(String::from("hello"))selfcallm.call()

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

`选项` enum 及其相对于 null 值的优势

本节探讨了的一个案例研究，它是定义的另一个枚举由 Standard 库。该类型对该值可以是某物，也可以是 Nothing。OptionOption

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

编程语言设计通常被认为是您具有哪些功能 include，但您排除的功能也很重要。Rust 没有 null 功能。Null 是一个值，表示在那里没有价值。在具有 null 的语言中，变量始终可以位于以下两种状态：null 或 not-null。

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

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

空值的问题在于，如果您尝试将 null 值用作 not-null 值，则会收到某种错误。因为这个 null 或不为 null property 无处不在，因此很容易犯这种错误。

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

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

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

枚举非常有用，它甚至包含在 prelude 中;你不需要显式地将其引入范围。它的变体也包含在前言：您可以直接使用 and，无需前缀。枚举仍然只是一个常规枚举，并且仍然是 type 的变体。Option<T>SomeNoneOption::Option<T>Some(T)NoneOption<T>

语法是我们尚未讨论的 Rust 的一个功能。这是一个泛型类型参数，我们将在第 10 章中更详细地介绍泛型。现在，您需要知道的是，这意味着枚举可以保存一条任何类型的数据，并且每个具体类型，用于代替 make the overall type 不同的类型。以下是使用 values 来保持数字类型和字符串类型：<T><T>SomeOptionTOption<T>Option

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

的类型是。的类型是，这是一种不同的类型。Rust 可以推断这些类型，因为我们在 variant 中指定了一个值。对于， Rust 需要我们对整体类型进行注释：编译器无法推断出 type 中，相应的 variant 将通过仅查看一个值来保存。在这里，我们告诉 Rust 我们的意思是 for 的类型为。some_numberOption<i32>some_charOption<char>Someabsent_numberOptionSomeNoneabsent_numberOption<i32>

当我们有一个值时，我们知道一个值是存在的，并且这个值为在 .当我们有一个值时，在某种意义上它意味着与 null 相同：我们没有有效的值。那么，为什么拥有比拥有 null 更好呢？SomeSomeNoneOption<T>

简而言之，因为和（其中可以是任何类型）是不同的类型，编译器不会让我们像使用 Value 一样使用绝对是一个有效的值。例如，这段代码不会编译，因为它是尝试将 an 添加到：Option<T>TTOption<T>i8Option<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 不明白添加 an 和 an ，因为它们是不同的类型。当我们具有 Rust 中的类型，编译器将确保我们的始终具有有效值。我们可以放心地进行，而无需检查 for null。只有当我们有（或无论我们正在使用哪种类型的值）我们都必须担心没有值，编译器将确保我们在使用值。i8Option<i8>i8Option<i8>

换句话说，您必须先将 an 转换为 a 使用它执行作。通常，这有助于捕捉到最 null 的常见问题：假设某些内容不是 null，而实际上它是 null。Option<T>TT

消除错误地假设非 null 值的风险有助于您对代码更有信心。为了获得一个可能为 null，则必须通过将 type of that value . 然后，当您使用该值时，您需要显式处理 case 当值为 null 时。在值具有非 type 的任何地方，您都可以安全地假设该值不为 null。这是一个 Rust 的深思熟虑的设计决策，以限制 null 的普遍性和增加 Rust 代码的安全性。Option<T>Option<T>

那么，当你有一个值时，你如何从 variant 中获取 value 的类型，以便您可以使用该值？枚举具有在各种情况下有用的大量方法;您可以在其文档中查看它们。逐渐熟悉使用这些方法在您的旅程中将非常有用锈。TSomeOption<T>Option<T>Option<T>

通常，为了使用值，您希望代码将处理每个变体。你想要一些仅在你有值时运行的代码，并且允许此代码使用内部的 .你想要一些 other code （其他代码）仅在您有值且该代码没有可用值时运行。表达式是一个控制流结构，它当与 enum 一起使用时，它只会这样做：它将运行不同的代码，具体取决于它所具有的枚举的变体，并且该代码可以使用 matching 值。Option<T>Some(T)TNoneTmatch

Rust 编程语言

定义枚举

枚举值

选项 enum 及其相对于 null 值的优势

`选项` enum 及其相对于 null 值的优势