Rust 枚举：enum 类型与模式匹配

枚举是 Rust 中一种强大的类型，它允许你定义一个只能取特定值之一的类型。配合模式匹配，枚举能够让你的代码既安全又优雅。

1. 为什么需要枚举

假设你正在开发一个表示IP地址的程序。IP 地址只能是 IPv4 或 IPv6 两种类型之一。如果用传统的结构体，你需要用额外的字段来区分类型：

struct IpAddress {
    kind: u8,  // 0 表示 IPv4，1 表示 IPv6
    address: String,
}

这种方式有几个明显的问题。第一，数字 0 和 1 的含义不明确，阅读代码的人需要猜测其含义。第二，没有任何机制能阻止你创建一个 kind = 2 的地址——这个值在语义上是无效的。第三，所有使用这个结构体的地方都必须同时处理这两个字段，即使你只想表示一个简单的地址。

枚举正是为解决这类问题而生的。它能精确地限定一个类型的合法值集合。

2. 定义基本枚举

使用 enum 关键字定义枚举，列举出所有可能的变体：

enum IpAddressKind {
    V4,
    V6,
}

struct IpAddress {
    kind: IpAddressKind,
    address: String,
}

fn main() {
    let home = IpAddress {
        kind: IpAddressKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddress {
        kind: IpAddressKind::V6,
        address: String::from("::1"),
    };
}

每个枚举变体都通过 枚举名::变体名 的形式访问，这种全限定路径清晰地表明了你使用的是哪个枚举中的哪个值。

3. 枚举变体可以携带数据

上面的例子中，枚举变体是简单的空标记。更强大的地方在于，变体可以直接关联数据：

enum IpAddress {
    V4(String),
    V6(String),
}

fn main() {
    let home = IpAddress::V4(String::from("127.0.0.1"));
    let loopback = IpAddress::V6(String::from("::1"));
}

Rust 允许你为每个变体定义不同的数据结构，这让代码更加灵活：

enum Message {
    Quit,                       // 空变体，不需要额外数据
    Move { x: i32, y: i32 },    // 匿名结构体
    Write(String),              // 单个字符串
    ChangeColor(i32, i32, i32), // 三个整数
}

这种设计让每个变体都能携带最适合自己的数据，而不是被迫使用统一的结构。

4. Option 枚举：Rust 的空值处理

在其他语言中，变量可能是有值，也可能是「空」（null）。但 null 带来一个根本问题：当你使用一个可能是 null 的值时，你永远无法确定它是否真的存在值，必须手动检查。这种检查很容易被遗忘，导致运行时错误。

Rust 采取了完全不同的策略。语言层面没有 null，而是提供了一个标准的 Option<T> 枚举：

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

<T> 是 Rust 的泛型语法，表示 Option 可以包含任意类型的值。标准库已经将 Option 和它的两个变体纳入了 prelude，你不需要显式导入就可以直接使用。

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

    let absent_number: Option<i32> = None;

    // 使用时必须处理两种情况
    let sum = some_number + 5;  // 错误！不能直接运算 Option<T>
}

当你持有 Option<T> 类型的值时，Rust 强制你必须处理 Some 和 None 两种可能。如果你尝试直接使用 Option 中的值，编译器会报错。这个设计从源头上杜绝了空值相关错误。

5. match 表达式：模式匹配基础

match 是 Rust 中最核心的控制流结构，它允许你将一个值与一系列模式进行比较，并执行匹配到的分支代码：

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 的工作原理是依次检查每个分支。第一个与值匹配的模式执行对应的代码，其余分支被忽略。

模式绑定值

变体可以携带数据，match 能够解构这些数据并绑定到变量：

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

#[derive(Debug)]
struct UsState {
    name: String,
}

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.name);
            25
        }
    }
}

当匹配到 Quarter 变体时，携带的 UsState 值被绑定到变量 state，可以在分支代码中使用。

6. match 的必须穷尽性

Rust 编译器会检查 match 是否覆盖了所有可能的值。如果你漏掉了某个变体，程序无法编译：

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
        // 忘记处理 None，编译器会报错
    }
}

这个检查保证了所有情况都被处理，不会有遗漏。对于 Option，你必须同时处理 Some 和 None。

使用通配符处理剩余情况

当你不需要关心某些特定值时，可以使用 _ 作为通配符：

let dice_roll = 7;
match dice_roll {
    1 => println!("Rolled a 1"),
    2 => println!("Rolled a 2"),
    3 => println!("Rolled a 3"),
    other => println!("Rolled something else: {}", other),  // 绑定剩余值
}

如果你只需要匹配某些特定值，而对其他值不感兴趣，可以使用 _ 本身（不绑定）：

match dice_roll {
    1 => println!("Rolled a 1"),
    2 => println!("Rolled a 2"),
    _ => (),  // 其他所有情况都不做任何事
}

7. if let：单模式匹配的简洁语法

当你只需要匹配一个模式，而忽略其他所有情况时，if let 提供了一个更简洁的写法。比较下面两种写法：

// 使用 match
let config_max = Some(3u8);
match config_max {
    Some(max) => println!("The maximum is configured to {}", max),
    _ => (),  // 必须处理其他情况，即使什么也不做
}

// 使用 if let
let config_max = Some(3u8);
if let Some(max) = config_max {
    println!("The maximum is configured to {}", max);
}

if let 的语法是 if let 模式 = 值 { ... }。它检查值是否匹配模式，如果匹配就执行代码块。

搭配 else 处理其他情况

if let 可以搭配 else 来处理未匹配的情况：

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

8. 实战示例：简单的状态机

枚举和模式匹配非常适合实现状态机。以下是一个简化的 TCP 连接状态示例：

enum TcpState {
    Closed,
    Listening,
    Established,
    Closing,
}

fn process_state(state: TcpState) {
    match state {
        TcpState::Closed => println!("Connection is closed"),
        TcpState::Listening => println!("Waiting for incoming connections"),
        TcpState::Established => println!("Data can be transferred"),
        TcpState::Closing => println!("Connection is shutting down"),
    }
}

fn main() {
    let states = [
        TcpState::Closed,
        TcpState::Listening,
        TcpState::Established,
        TcpState::Closing,
    ];

    for state in &states {
        process_state(*state);
    }
}

这个例子展示了枚举如何清晰地表达有限状态集合，match 如何优雅地处理每种状态的逻辑。

9. 核心要点回顾

枚举让你能够定义一个类型的所有合法取值，从根本上防止无效值的存在。Option<T> 通过 Some 和 None 两个变体，在不引入 null 的情况下安全地处理「可能有值」的情况。match 表达式强制你处理所有可能性，编译器会捕获任何遗漏。if let 为简单的单模式匹配提供了更简洁的语法。

这套组合拳让 Rust 代码既安全又清晰——你不必担心遗漏某个边界情况，因为编译器会提醒你；你也无需在代码中写满空值检查，因为 Option 的类型系统会替你把关。