JZTXT

枚举和模式匹配

发布时间 2023-03-22 21:13:33作者: 点解我最型

枚举允许你通过列举可能的成员来定义一个类型

定义枚举

任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是，IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员，IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理适用于任何类型的 IP 地址的场景时应该把它们当作相同的类型

可以通过在代码中定义一个 IpAddrKind 枚举来表现这个概念并列出可能的 IP 地址类型，V4 和 V6

enum IpAddrKind {
    V4,
    V6,
}

枚举值

可以像这样创建 IpAddrKind 两个不同成员的实例

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

注意枚举的成员位于其标识符的命名空间中，并使用两个冒号分开，这么设计的益处是现在 IpAddrKind::V4 和 IpAddrKind::V6 都是 IpAddrKind 类型的，例如，接着可以定义一个函数来获取任何 IpAddrKind

fn route(ip_type: IpAddrKind) { }

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

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

枚举与结构体

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

我们可以使用一种更简洁的方式来表达相同的概念，仅仅使用枚举并将数据直接放进每一个枚举成员而不是将枚举作为结构体的一部分

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

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

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

我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了

用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据，IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分，如果我们想要将 V4 地址存储为四个 u8 值而 V6 地址仍然表现为一个 String，这就不能使用结构体了，枚举则可以轻易地处理这个情况

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);

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

让我们看看标准库是如何定义 IpAddr 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的

struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

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

这些代码展示了可以将任意类型的数据放入枚举成员中：例如字符串、数字类型或者结构体

来看下一个例子

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

这个枚举有四个含有不同类型的成员：

  • Quit 没有关联任何数据
  • Move 包含一个匿名结构体
  • Write 包含单独一个 String
  • ChangeColor 包含三个 i32

定义一个如上所示那样的有关联值的枚举的方式和定义多个不同类型的结构体的方式很相像，除了枚举不使用 struct 关键字以及其所有成员都被组合在一起位于 Message 类型下，如下这些结构体可以包含与之前枚举成员中相同的数据

struct QuitMessage; // 类单元结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

不过，如果我们使用不同的结构体，由于它们都有不同的类型，我们将不能像使用定义的 Message 枚举那样，轻易的定义一个能够处理这些不同类型的结构体的函数，因为枚举是单独一个类型

枚举和结构体还有另一个相似点：就像可以使用 impl 来为结构体定义方法那样，也可以在枚举上定义方法。这是我们在 Message 枚举上定义了一个叫做 call 的方法

impl Message {
    fn call(&self) {
        // 在这里定义方法体
    }
}

let m = Message::Write(String::from("hello"));
m.call();

方法体使用了 self 来获取调用方法的值。这个例子中，创建了一个值为 Message::Write(String::from("hello")) 的变量 m，而且这就是当 m.call() 运行时 call 方法中的 self 的值

Option 枚举和其相对于空值的优势

Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值，从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug

然而，空值尝试表达的概念仍然是有意义的：空值是一个因为某种原因目前无效或缺失的值

Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举，这个枚举是 Option<T>，而且它定义于标准库中，如下

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

Option<T> 枚举是如此有用以至于它甚至被包含在了 prelude 之中，你不需要将其显式引入作用域，另外，它的成员也是如此，可以不需要 Option:: 前缀来直接使用 Some 和 None

let some_number = Some(5)
let some_string = Some("a string")

let absent_number: Option<i32> = None

如果使用 None 而不是 Some，需要告诉 Rust Option<T> 是什么类型的，因为编译器只通过 None 值无法推断出 Some 成员保存的值的类型

简而言之，因为 Option<T> 和 T（这里 T 可以是任何类型）是不同的类型，编译器不允许像一个肯定有效的值那样使用 Option<T>，例如，这段代码不能编译，因为它尝试将 Option<i8> 与 i8 相加

let x: i8 = 5
let y: Option<i8> = Some(5)

let sum = x + y

如果运行这些代码，将得到类似这样的错误信息：

error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is
not satisfied
 -->
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + std::option::Option<i8>`
  |

事实上，错误信息意味着 Rust 不知道该如何将 Option<i8> 与 i8 相加，因为它们的类型不同，当在 Rust 中拥有一个像 i8 这样类型的值时，编译器确保它总是有一个有效的值，我们可以自信使用而无需做空值检查，只有当使用 Option<i8>（或者任何用到的类型）的时候需要担心可能没有值，而编译器会确保我们在使用值之前处理了为空的情况

换句话说，在对 Option<T> 进行 T 的运算之前必须将其转换为 T，通常这能帮助我们捕获到空值最常见的问题之一：假设某值不为空但实际上为空的情况

不再担心会错误的假设一个非空值，会让你对代码更加有信心，为了拥有一个可能为空的值，必要显式的将其放入对应类型的 Option<T> 中，接着，当使用这个值时，必须明确地处理值为空的情况，只要一个值不是 Option<T> 类型，你就可以安全的认定它的值不为空，这是 Rust 的一个经过深思熟虑的设计决策，来限制空值的泛滥以增加 Rust 代码的安全性

那么当有一个 Option<T> 的时，如何从 Some 成员中取出 T 的值来使用它呢？Option<T> 枚举拥有大量用于各种情况的方法：你可以查看它的文档

match 控制流运算符

Rust 有一个叫做 match 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码，模式可由字面量、变量、通配符和许多其他内容构成，match 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理

可以把 match 表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会通过 match 的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用

因为刚刚提到了硬币，让我们用它们来作为一个使用 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,
    }
}

如果分支代码较短的话通常不使用大括号，如果想要在分支中运行多行代码，可以使用大括号

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

绑定值的模式

匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值，也就是如何从枚举成员中提取值的

作为一个例子，让我们修改枚举的一个成员来存放数据，1999 年到 2008 年间，美国在 25 美分的硬币的一侧为 50 个州的每一个都印刷了不同的设计，其他的硬币都没有这种区分州的设计，所以只有这些 25 美分硬币有特殊的价值，可以将这些信息加入我们的 enum，通过改变 Quarter 成员来包含一个 State 值

#[derive(Debug)] // 这样可以立刻看到州的名称
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

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

我们在匹配 Coin::Quarter 成员的分支的模式中增加了一个叫做 state 的变量，当匹配到 Coin::Quarter 时，变量 state 将会绑定 25 美分硬币所对应州的值，接着在那个分支的代码中使用 state

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

如果调用 value_in_cents(Coin::Quarter(UsState::Alaska))，coin 将是 Coin::Quarter(UsState::Alaska)，当将值与每个分支相比较时，没有分支会匹配，直到遇到 Coin::Quarter(state)，这时，state 绑定的将会是值 UsState::Alaska，接着就可以在 println! 表达式中使用这个绑定了，像这样就可以获取 Coin 枚举的 Quarter 成员中内部的州的值

匹配 Option

我们在之前的部分中使用 Option<T> 时，是为了从 Some 中取出其内部的 T 值；我们还可以像处理 Coin 枚举那样使用 match 处理 Option<T>！只不过这回比较的不再是硬币，而是 Option<T> 的成员，但 match 表达式的工作方式保持不变

比如我们想要编写一个函数，它获取一个 Option<i32> ，如果其中含有一个值，将其加一，如果其中没有值，函数应该返回 None 值，而不尝试执行任何操作

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

匹配是穷尽的

match 还有另一方面需要讨论，考虑一下 plus_one 函数的这个版本，它有一个 bug 并不能编译

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
    }
}

我们没有处理 None 的情况，所以这些代码会造成一个 bug

Rust 知道我们没有覆盖所有可能的情况甚至知道哪些模式被忘记了！Rust 中的匹配是穷举式的：必须穷举到最后的可能性来使代码有效，特别的在这个 Option<T> 的例子中，Rust 防止我们忘记明确的处理 None 的情况，这让我们免于假设拥有一个实际上为空的值，从而使之前提到的价值亿万的错误不可能发生

通配模式和 _ 占位符

let dice_roll = 9;
match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    other => move_player(other),
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}

对于前两个分支，匹配模式是字面值 3 和 7，最后一个分支则涵盖了所有其他可能的值，模式是我们命名为 other 的一个变量，other 分支的代码通过将其传递给 move_player 函数来使用这个变量

即使我们没有列出 u8 所有可能的值，这段代码依然能够编译，因为最后一个模式将匹配所有未被特殊列出的值，这种通配模式满足了 match 必须被穷尽的要求，请注意，我们必须将通配分支放在最后，因为模式是按顺序匹配的，如果我们在通配分支后添加其他分支，Rust 将会警告我们，因为此后的分支永远不会被匹配到

Rust 还提供了一个模式，当我们不想使用通配模式获取的值时，请使用 _ ，这是一个特殊的模式，可以匹配任意值而不绑定到该值，这告诉 Rust 我们不会使用这个值，所以 Rust 也不会警告我们存在未使用的变量

让我们改变游戏规则，当你掷出的值不是 3 或 7 的时候，你必须再次掷出，这种情况下我们不需要使用这个值，所以我们改动代码使用 _ 来替代变量 other

let dice_roll = 9;
match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    _ => reroll(),
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn reroll() {}

这个例子也满足穷举性要求，因为我们在最后一个分支中明确地忽略了其他的值，我们没有忘记处理任何东西

让我们再次改变游戏规则，如果你掷出 3 或 7 以外的值，你的回合将无事发生，我们可以使用单元值作为 _ 分支的代码

let dice_roll = 9;
match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    _ => (),
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}

在这里，我们明确告诉 Rust 我们不会使用与前面模式不匹配的值，并且这种情况下我们不想运行任何代码

if let 简单控制流

if let 语法让我们以一种不那么冗长的方式来处理只匹配一个模式的值而忽略其他模式的情况

我们想要对 Some(3) 匹配进行操作但是不想处理任何其他 Some<u8> 值或 None 值

let some_u8_value = Some(0u8);
match some_u8_value {
    Some(3) => println!("three"),
    _ => (),
}

改为：

let some_u8_value = Some(0u8);
if let Some(3) = some_u8_value {
    println!("three");
}

if let 获取通过等号分隔的一个模式和一个表达式

使用 if let 意味着编写更少代码，更少的缩进和更少的样板代码，然而，这样会失去 match 强制要求的穷尽性检查，match 和 if let 之间的选择依赖特定的环境以及增加简洁度和失去穷尽性检查的权衡取舍

换句话说，可以认为 if let 是 match 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值

可以在 if let 中包含一个 else，else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else

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

相当于：

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