Rust学习笔记之枚举和匹配模式

2023-03-23 19:51:17 浏览数 (1)

❝厉害很重要，但是让别人知道你很厉害更重要❞

大家好，我是「柒八九」。

今天，我们继续「Rust学习笔记」的探索。我们来谈谈关于「枚举和匹配模式」的相关知识点。

如果，想了解该系列的文章，可以参考我们已经发布的文章。如下是往期文章。

文章list

  1. Rust学习笔记之Rust环境配置和入门指南
  2. Rust学习笔记之基础概念
  3. Rust学习笔记之所有权
  4. Rust学习笔记之结构体

你能所学到的知识点

❝

  1. Rust中枚举类型 「推荐阅读指数」 ⭐️⭐️⭐️⭐️⭐️
  2. match 控制流运算符 「推荐阅读指数」 ⭐️⭐️⭐️⭐️
  3. if let 简单控制流 「推荐阅读指数」 ⭐️⭐️⭐️⭐️❞

好了，天不早了，干点正事哇。

枚举enumerations，也被称作 enums。枚举允许你通过「列举可能的成员variants来定义一个类型」。

定义枚举

假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。

任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为「枚举值只可能是其中一个成员」。

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

代码语言：javascript复制
enum IpAddrKind {
    V4,
    V6,
}

现在 IpAddrKind 就是一个可以在代码中使用的「自定义数据类型」了。

枚举值

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

代码语言：javascript复制
fn main() {
  enum IpAddrKind {
      V4,
      V6,
  }

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

❝枚举的成员位于其标识符的「命名空间中」，并「使用两个冒号分开」。 ❞

用枚举替代结构体还有另一个优势：「每个成员可以处理不同类型和数量的数据」。

代码语言：javascript复制
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"));
}

枚举的成员中内嵌了多种多样的类型：

代码语言：javascript复制
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

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

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

❝枚举和结构体还有另一个相似点：就像可以使用 impl 来为结构体定义方法那样，也可以在枚举上定义方法。 ❞

代码语言：javascript复制

fn main() {
  #[derive(Debug)]
  enum Message {
      Quit,
      Move { x: i32, y: i32 },
      Write(String),
      ChangeColor(i32, i32, i32),
  }

  impl Message {
      fn call(&self) {
          println!("{:?}",self)
      }
  }

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

方法体使用了 self 来获取调用方法的值。此时输出结果为Write("hello")

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

Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即「一个值要么有值要么没值」。

❝Rust 并没有很多其他语言中有的「空值功能」。空值（Null ）是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一：「空值和非空值」。 ❞

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

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

代码语言：javascript复制
enum Option<T> {
    Some(T),
    None,
}

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

<T> 语法是一个「泛型类型参数」。目前，所有你需要知道的就是 <T> 意味着 Option 枚举的 Some 成员「可以包含任意类型的数据」。

代码语言：javascript复制
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>

代码语言：javascript复制
let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x   y;

这段代码不能编译，因为它尝试将 Option<T> 与 i8 相加。

❝换句话说，在对 Option<T> 进行 T 的运算之前必须将其转换为 T。 ❞

match 控制流运算符

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

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

代码语言：javascript复制
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 关键字后「跟一个表达式」，在这个例子中是 coin 的值。这看起来非常像 if 使用的表达式，不过这里有一个非常大的区别：对于 if，表达式「必须返回一个布尔值」，而「这里它可以是任何类型」的
  • match 的分支。一个分支有「两个部分」：一个模式和一些代码。
    • 第一个分支的模式是值 Coin::Penny
    • 而之后的 => 运算符将模式和「将要运行的代码」分开。
    • 每一个分支之间使用「逗号分隔」。

当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较。如果模式匹配了这个值，这个模式相关联的代码将被执行。如果模式并不匹配这个值，将继续执行下一个分支。

❝每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值。 ❞

如果想要在分支中「运行多行代码」，可以使用大括号。

代码语言：javascript复制
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

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

匹配 Option<T>

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

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

代码语言：javascript复制
fn main() {
    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);
}

匹配 Some(T)

仔细地检查 plus_one 的第一行操作。当调用 plus_one(five) 时，plus_one 函数体中的 x 将会是值 Some(5)。接着将其与每个分支比较。

代码语言：javascript复制
None => None,

值 Some(5) 并不匹配模式 None，所以继续进行下一个分支。

代码语言：javascript复制
Some(i) => Some(i   1),

Some(5) 与 Some(i) 匹配。它们是相同的成员。i 绑定了 Some 中包含的值，所以 i 的值是 5。接着匹配分支的代码被执行，所以我们将 i 的值加一并返回一个含有值 6 的新 Some。

匹配是穷尽的

代码语言：javascript复制
fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i   1),
        }
    }
}

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

❝Rust 中的匹配是穷举式exhaustive的：必须穷举到最后的可能性来使代码有效 ❞

通配模式和 _ 占位符

我们希望「对一些特定的值采取特殊操作，而对其他的值采取默认操作」。

想象我们正在玩一个游戏，如果你掷出骰子的值为 3，角色不会移动，而是会得到一顶新奇的帽子。如果你掷出了 7，你的角色将失去新奇的帽子。对于其他的数值，你的角色会在棋盘上移动相应的格子。

代码语言：javascript复制
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) {}
}

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

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

改变游戏规则，当你掷出的值不是 3 或 7 的时候，你必须再次掷出

代码语言：javascript复制
fn main() {
    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() {}
}

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

if let 简单控制流

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

存在如下的程序，它匹配一个 Option<u8> 值并只希望当值为 3 时执行代码：

代码语言：javascript复制

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

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

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

代码语言：javascript复制
fn main() {
  let some_u8_value = Some(0u8);
  if let Some(3) = some_u8_value {
      println!("three");
  }
}

if let 获取「通过等号分隔的一个模式和一个表达式」。它的工作方式与 match 相同，这里的表达式对应 match 而模式则「对应第一个分支」。

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

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

代码语言：javascript复制
let mut count = 0;
match coin {
    Coin::Quarter(state) => println!("钱的面值为{:?}!", state),
    _ => count  = 1,
}

使用if let 进行改写。

代码语言：javascript复制
let mut count = 0;
  if let Coin::Quarter(state) = coin {
      println!("钱的面值为{:?}!", state);
  } else {
      count  = 1;
  }

如果你的程序遇到一个使用 match 表达起来过于啰嗦的逻辑，可以使用if let对其改写。

rust 变量 函数 学习笔记 语法

0 人点赞