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

在这里，我们定义了一个结构体IpAddr，它有两个字段：一个kind字段属于类型IpAddrKind（我们之前定义的枚举）和address田的类型String.我们有这个结构的两个实例。首先是home, 它的值IpAddrKind::V4作为其kind与关联的地址数据127.0.0.1.第二个实例是loopback.它有另一个的变体IpAddrKind作为其kind价值V6，并且具有地址::1与之相关联。我们使用了一个结构体来捆绑kind和address值一起，因此现在 variant 与值相关联。

但是，仅使用 enum 表示相同的概念更简洁：我们可以将数据直接放入每个枚举中，而不是在结构体中放置枚举变体。这个IpAddrenum 表示两者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"));
}

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

使用 enum 而不是 struct 还有另一个好处：每个变体可以具有不同类型和数量的关联数据。版本 4 IP addresses 将始终具有四个数字部分，这些部分将具有 Value 介于 0 和 255 之间。如果我们想存储V4地址为 4u8值，但仍然快递V6地址为 1Stringvalue 中，我们将无法使用一个 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"));
}

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

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

struct Ipv6Addr {
    // --snip--
}

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

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

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

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

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

fn main() {}

示例 6-2：一个Messageenum 的变体每个存储不同的值数量和类型

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

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

使用示例 6-2 中的变体定义枚举类似于定义不同类型的结构体定义，但 enum 不使用structkeyword 的 Keyword 和所有变体都归入Message类型。以下结构可以保存与前面的枚举相同的数据 variants 成立：

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

但是如果我们使用不同的结构体，每个结构体都有自己的类型，那么无法像我们可以使用Messageenum 定义在示例 6-2 中，它是一个单一类型。

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

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获取我们调用 method 打开。在此示例中，我们创建了一个变量m具有Message::Write(String::from("hello"))，这就是self将位于 body 的callmethod 时m.call()运行。

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

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

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

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

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

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

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

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

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

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

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

这Option<T>enum 非常有用，它甚至包含在 Prelude 中;你不需要显式地将其引入范围。它的变体也包含在序言：您可以使用Some和None直接而不使用Option::前缀。这Option<T>enum 仍然只是一个常规的 enum，而Some(T)和None仍然是 type 的变体Option<T>.

这<T>语法是 Rust 的一个特性，我们还没有讨论过。这是一个泛型类型参数，我们将在第 10 章中更详细地介绍泛型。现在，您需要知道的是<T>表示Some的变体这Optionenum 可以保存一条任何类型的数据，并且每个具体类型，用于代替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锈要求我们注释整体Optiontype：编译器无法推断出 type 中对应的Somevariant 将成立，方法是仅查看None价值。在这里，我们告诉 Rust 我们的意思是absent_number为 typeOption<i32>.

当我们有一个Somevalue 时，我们知道存在一个值，并且值为在Some.当我们有一个Nonevalue 中，在某种意义上它意味着与 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>，因为它们是不同的类型。当我们具有类似i8在 Rust 中，编译器将确保我们始终具有有效值。我们可以放心地进行，而无需检查 for null。只有当我们有Option<i8>（或无论我们正在使用哪种类型的值）我们都必须担心没有值，编译器将确保我们在使用值。

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

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

那么，如何获取Tvalue 从Somevariant （当您具有的类型Option<T>以便您可以使用该值？这Option<T>enum 的在各种情况下有用的大量方法;您可以在其文档中查看它们。逐渐熟悉打开方法Option<T>在您的旅程中将非常有用锈。

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

Rust 编程语言

定义枚举

枚举值

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

Rust 编程语言

定义枚举

枚举值

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

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