5.4 枚举类型（enum）

枚举（enum）是 Rust 中一种强大的数据类型，它允许你定义一个类型，该类型可以是多个可能变体（variant）中的一个。与许多其他语言中的枚举不同，Rust 的枚举不仅仅是简单的常量列表，每一个变体都可以包含不同类型和数量的关联数据。这使得枚举成为表达和处理多种可能状态或结构的理想工具，是 Rust 类型系统的核心特性之一。

5.4.1 定义枚举

使用 enum 关键字可以定义一个枚举。每个变体之间用逗号分隔。最简单的枚举类似于 C 语言中的枚举，只包含变体名称，没有关联数据。

// 定义一个表示 IP 地址类型的枚举
enum IpAddrKind {
    V4,
    V6,
}

这里，IpAddrKind 是一个枚举类型，它有两个变体：V4 和 V6。我们可以创建这个枚举类型的实例：

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

5.4.2 枚举变体携带数据

Rust 枚举的强大之处在于，每个变体可以携带不同类型和数量的数据。这些数据可以是基本类型、结构体、元组，甚至是另一个枚举。

// 一个更实用的 IP 地址枚举，变体携带数据
enum IpAddr {
    V4(String),      // V4 变体携带一个 String
    V6(String),      // V6 变体也携带一个 String
}

let home = IpAddr::V4(String::from("127.0.0.1"));
let loopback = IpAddr::V6(String::from("::1"));

我们甚至可以做得更好。V4 地址通常由四个 0-255 的数字组成，而 V6 地址是更复杂的字符串。我们可以让变体携带更精确的数据类型：

enum IpAddr {
    V4(u8, u8, u8, u8), // V4 变体携带四个 u8 值
    V6(String),          // V6 变体携带一个 String
}

let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));

这种灵活性是结构体无法直接提供的。如果我们用结构体来表示，可能需要定义多个结构体，或者使用一个结构体包含所有可能的数据，但很多字段会是空的。枚举则完美地解决了这个问题。

5.4.3 枚举与 match 控制流

match 是 Rust 中与枚举配合使用的最强大的控制流运算符。它允许你将一个枚举值与一系列模式进行匹配，并根据匹配到的模式执行相应的代码。match 必须穷举所有可能的变体，这确保了代码的安全性。

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

如果 match 分支的代码有多行，可以使用花括号 {}：

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

5.4.4 绑定值的模式

match 分支可以绑定到匹配的变体所携带的数据，从而在分支代码中使用这些数据。

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // ... 其他州
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState), // Quarter 变体携带一个 UsState 值
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }
}

let coin = Coin::Quarter(UsState::Alaska);
value_in_cents(coin); // 输出: "State quarter from Alaska!"

5.4.5 Option<T> 枚举：Rust 中的空值安全

Rust 中没有 null 值。为了处理值可能缺失的情况，标准库提供了一个非常重要的枚举：Option<T>。它的定义如下：

enum Option<T> {
    None,     // 表示值不存在
    Some(T),  // 表示值存在，并包装了类型为 T 的值
}

Option<T> 被包含在预导入模块中，因此你可以直接使用 Some 和 None，而无需使用 Option:: 前缀。

let some_number = Some(5);        // 类型是 Option<i32>
let some_string = Some("a string"); // 类型是 Option<&str>
let absent_number: Option<i32> = None; // 需要显式声明类型

使用 Option<T> 强制程序员在编译时处理值可能为 None 的情况，从而避免了空指针异常这一常见的编程错误。要使用 Option<T> 中的值，通常需要配合 match 表达式：

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

5.4.6 if let 简洁控制流

当你只关心一个特定的枚举变体，而希望忽略其他变体时，可以使用 if let 语法。它比 match 更简洁。

let config_max = Some(3u8);
match config_max {
    Some(max) => println!("The maximum is configured to be {}", max),
    _ => (), // 处理其他情况，这里什么都不做
}

// 使用 if let 可以简写为：
if let Some(max) = config_max {
    println!("The maximum is configured to be {}", max);
}

if let 可以看作是一个只匹配一个模式的 match 语句的语法糖。它也可以搭配 else 使用，对应 match 中的 _ => {} 分支。

let coin = Coin::Penny;
let mut count = 0;
if let Coin::Quarter(state) = coin {
    println!("State quarter from {:?}!", state);
} else {
    count += 1;
}

5.4.7 枚举的方法

与结构体类似，枚举也可以使用 impl 块来定义方法。

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

总结

枚举是 Rust 中一个核心且强大的特性。它允许你以类型安全的方式表达数据可能具有的多种形态，并通过 match 和 if let 等控制流结构进行精确处理。Option<T> 枚举是 Rust 空值安全策略的基石，它强制程序员在编译时考虑值缺失的可能性，从而编写出更健壮、更可靠的代码。掌握枚举是深入理解 Rust 类型系统和编写惯用 Rust 代码的关键一步。

Last Updated::