Rust-枚举和模式匹配

rust rust
Created At :
Views 👀 : Comment:
  1. 一、定义枚举
    1. 枚举值
    2. Option 枚举和其相对于空值的优势
  2. 二、match 控制流运算符
    1. 绑定值的模式
    2. 匹配 Option
    3. 匹配是穷尽的
    4. other模式 和 _ 通配符
  3. 三、if let 简单控制流
    1. if let 简单控制流

一、定义枚举

可以通过在代码中定义一个 IpAddrKind 枚举来表现这个概念并列出可能的 IP 地址类 型， V4 和 V6 。这被称为枚举的 成员(variants):

enum IpAddrKind {
    V4,
    V6,
}

枚举值

我们可以IpAddrKind像这样创建两个变体中的每一个的实例：

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

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

现在可以使用任一成员来调用这个函数:
route(IpAddrKind::V4);
route(IpAddrKind::V6);

使用枚举甚至还有更多优势。进一步考虑一下我们的 IP 地址类型，目前没有一个储存实际 IP 地址数据的方法;只知道它是什么类型的。考虑到已经学习过结构体了，你可能会像下面那样处理这个问题:
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"),
    };
}

这里我们定义了一个有两个字段的结构体 IpAddr : kind 字段是 IpAddrKind (之前定义的枚举)类型的而 address 字段是 String 类型的。这里有两个结构体的实例。第一个， home ，它的 kind 的值是 IpAddrKind::V4 与之相关联的地址数据是 127.0.0.1 。第二个实例， loopback ， kind 的值是 IpAddrKind 的另一个成员， V6 ，关联的地址是 ::1 。 我们使用了一个结构体来将 kind 和 address 打包在一起，现在枚举成员就与值相关联了。

通过将数据直接放入每个枚举变体中，我们可以仅使用枚举而不是结构内的枚举以更简洁的方式表示相同的概念。IpAddr枚举的这个新定义表示V4和V6 变体都将具有关联的String值：

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

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

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

用枚举替代结构体还有另一个优势:每个成员可以处理不同类型和数量的数据。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"));

这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了以致标准库提供了一个开箱即用的定义!让我们看看标准库是如何定义 IpAddr 的:它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的:
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

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

这些代码展示了可以将任意类型的数据放入枚举成员中:例如字符串、数字类型或者结构体。甚至可以包含另一个枚举!另外，标准库中的类型通常并不比你设想出来的要复杂多少。

注意虽然标准库中包含一个 IpAddr 的定义，仍然可以创建和使用我们自己的定义而不会有冲突，因为我们并没有将标准库中的定义引入作用域。

下面代码中，它的成员中内嵌了多种多样的类型:

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

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

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

除了枚举不使用字并且所有成员都被组合在一起位于 Message 下之外。如下这些结构体可以包含与之前枚举成员中相同的数据:

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

但是如果我们使用不同的结构，每个结构都有自己的类型。

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

impl Message {
    fn call(&self) {
        // method body would be defined here
    }
}

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

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

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

在之前的部分，我们看到了 IpAddr 枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。接下来我们分析一个 Option 的案例， Option 是标准库定义的另一个枚举。 Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么是某个值要么什 么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的bug。

编程语言的设计经常从其包含功能的角度考虑问题，但是从其所排除在外的功能的角度思考也很重要。Rust 并没有很多其他语言中有的空值功能。空值(Null)是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一:空值和非空值。

在 “Null References: The Billion Dollar Mistake” 中，Tony Hoare，null 的发明者，曾经说到:

I call it my billion-dollar mistake. At that time, I was designing the first comprehensive type system for references in an object-oriented language. My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
我称之为我十亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抵抗住引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数十亿美元的苦痛和伤害。

空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。
然而，空值尝试表达的概念仍然是有意义的:空值是一个因为某种原因目前无效或缺失的值。
问题不在于具体的概念而在于特定的实现。为此，Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是 Option<T> ，而且它定义于标准库中，如下:

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

Option<T> 是如此有用以至于它甚至被包含在了 prelude 之中，这意味着不需要显式引入作用域。另外，它的成员也是如此，可以不需要 Option:: 前缀来直接使用 Some 和 None 。即便如此 Option<T> 也仍是常规的枚举， Some(T) 和 None 仍是 Option<T> 的成员。

这里是一些包含数字类型和字符串类型 Option 值的例子:

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

let absent_number: Option<i32> = None;

如果使用 None 而不是 Some ，需要告诉 Option<T> 是什么类型的，因为编译器只通过 None 值无法推断出 Some 变量保留的值的类型。
当有一个 Some 值时，我们就知道存在一个值，而这个值保存在 Some 中。当有个 None 值时，在某种意义上它跟空值是相同的意义:并没有一个有效的值。那么， Option<T> 为什么就比空值要好呢?
简而言之，因为 Option<T> 和 T (这里 T 可以是任何类型)是不同的类型，编译器不允许像一个被定义的有效的类型那样使用 Option<T> 。
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`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` due to previous error

错误信息意味着 Rust 不知道该如何将 Option<i8> 与 i8 相加。在对 Option<T> 进行 T 的运算之前必须将其转换为 T 。通常这能帮助我们捕获空值最常见的问题之一:假设某值不为空但实际上为空的情况。

那么当有一个 Option<T> 的值时，如何从 Some 成员中取出 T 的值来使用它呢? Option<T> 枚举拥有大量用于各种情况的方法:你可以查看相关代码。熟悉 Option 的方法将对你的 Rust 之旅提供巨大的帮助。

总的来说，为了使用 Option<T> 值，需要编写处理每个成员的代码。我们想要一些代码只当 拥有 Some(T) 值时运行，这些代码允许使用其中的 T 。也希望一些代码在 None 值时运行，这些代码并没有一个可用的 T 值。 match 表达式就是这么一个处理枚举的控制流结构:它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。

二、match 控制流运算符

Rust 有一个叫做 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,
    }
}

拆开 value_in_cents 函数中的 match 来看。首先，我们列出 match 关键字后跟一个表达式，在这个例子中是 coin 的值。这看起来非常像 if 使用的表达式，不过这里有一个非常大的区别:对于 if ，表达式必须返回一个布尔值。而这里它可以是任何类型的。
接下来是 match 的分支。一个分支有两个部分:一个模式和一些代码。第一个分支的模式是值 Coin::Penny 而之后的 => 运算符将模式和将要运行的代码分开。这里的代码就仅仅是值1 。每一个分支之间使用逗号分隔。
当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较，如果模式匹配了这个值，这个模式相关联的代码将被执行。
每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 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,
    }
}

绑定值的模式

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

#[derive(Debug)] // so we can inspect the state in a minute
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 。

匹配 Option

在之前的部分在使用 Option<T> 时我们想要从 Some 中取出其内部的 T 值;也可以像处理 Coin 枚举那样使用 match 处理 Option<T> !

比如我们想要编写一个函数，它获取一个 Option<i32> 并且如果其中有一个值，将其加一。如果其中没有值，函数应该返回 None 值并不尝试执行任何操作。
得益于 match ，编写这个函数非常简单

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

fn main() {
    let five = Some(5);

    let six = plus_one(five); let none = plus_one(None);
    fn main() {
        let i = value_in_cents(Coin::Quarter(UsState::Alabama));
        println!("{}", i);
    }
}

匹配是穷尽的

match 还有另一方面需要讨论。考虑一下 plus_one 函数的这个版本:

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

我们没有处理这个None案例，所以这段代码会导致一个错误。
cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
   --> src/main.rs:3:15
    |
3   |         match x {
    |               ^ pattern `None` not covered
    |
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
    = note: the matched value is of type `Option<i32>`

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` due to previous error

Rust 知道我们没有涵盖所有可能的情况，甚至知道我们忘记了哪种模式！Rust 中的匹配是详尽无遗的：我们必须穷尽所有最后的可能性才能使代码有效。特别是在的情况下 Option<T>，当 Rust 防止我们忘记显式处理这个Nonecase 时，它可以保护我们避免在我们可能有 null的情况下假设我们有一个值，

other模式 和 _ 通配符

对于其他的值，提供了ohter(很像switch中的default)：

fn main() {
    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) {}
}

即使我们没有列出 u8 可以具有的所有可能值，此代码也会编译， 因为最后一个模式将匹配所有未特别列出的值。注意，我们必须将其放在最后，否则rust会基于警告。

Rust 还有一个模式，当我们不想使用 catch-all 模式中的值时，我们可以使用_它：，这是一个特殊的模式，可以匹配任何值并且不绑定到该值。这告诉 Rust 我们不会使用这个值，所以 Rust 不会警告我们一个未使用的变量。
在这种情况下，我们不需要使用该值，因此我们可以更改我们的代码来使用，_而不是使用名为的变量other：

let some_u8_value = 0u8; match some_u8_value {
    1 => println!("one"),
    3 => println!("three"),
    5 => println!("five"),
    7 => println!("seven"),
    _ => (),
}

三、if let 简单控制流

if let 简单控制流

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

let config_max = Some(3u8);
match config_max {
    Some(max) => println!("The maximum is configured to be {}", max),
    _ => (),
}

我们想要对 Some(3) 匹配进行操作但是不想处理任何其他 Some(u8) 值或 None 值。为了满足 match 表达式(穷尽性)的要求，必须在处理完这唯一的成员后加上 _ => () ，这样也 要增加很多样板代码。

不过我们可以使用 if let 这种更短的方式编写。

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

if let 获取通过 = 分隔的一个模式和一个表达式。它的工作方式与 match 相同，这里的表达式对应 match 而模式则对应第一个分支。
使用 if let 意味着编写更少代码，更少的缩进和更少的样板代码。然而，这样会失去 match 强制要求的穷尽性检查。 match 和 if let 之间的选择依赖特定的环境以及增加简洁度和失去穷尽性检查的权衡取舍
换句话说，可以认为 if let 是 match 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。
可以在 if let 中包含一个 else 。 else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else 。
let mut count = 0;
match coin {
    Coin::Quarter(state) => println!("State quarter from {:?}!", state),
    _ => count += 1,
}

或者我们可以使用这样的if let 和 else表达式：
let mut count = 0;
if let Coin::Quarter(state) = coin {
    println!("State quarter from {:?}!", state);
} else {
    count += 1;
}

如果您的程序的逻辑过于冗长而无法使用来表达match，请记住这if let也在您的 Rust 工具箱中。

©2016-2020 Yangandmore

Built with Hexo and 3-hexo theme