在先前的章节中我们已经稍微用过 Result 枚举了,在这个章节中,我们将会学着定义自己的枚举类型,以及使用另一个同样是由 Rust 内置,也很常用的 Option 枚举。枚举和同样我们先前已经用过的 match 关键字经常互相搭配着使用,在这个章节中,我们也会更深入地学习 match 关键字和 if let、while let 语法的用法。

先举一个例子来说明枚举的用途。现在我们需要用 Rust 程序来处理 IP 地址,而 IP 地址有两个主要版本,分别是 32 比特的「IPv4」和 128 比特的「IPv6」,我们的程序也只要处理这两种版本的 IP 地址。所有的 IP 地址都一定是属于「IPv4」或是「IPv6」,但不能同时是「IPv4」和「IPv6」。我们可以定义出一个 IP 地址种类的枚举 IpAddrKind,且这个枚举有 V4、V6 两种变体(variant)。程序如下:

enum IpAddrKind {
    V4,
    V6,
}

枚举与结构体类似,定义出来后只是一个类型,要作为「值」使用的话一样还要经过实体化。IpAddrKind 枚举可以实体化出 V4 和 V6 两种不同类型的值,实体化的代码如下:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;
}

实体化出枚举值的方式十分简单。以上程序,four 和 six 变量的类型都是 IpAddrKind,也就是说如果要将它们传入函数作为参数使用,参数的类型可以使用 IpAddrKind。例如:

enum IpAddrKind {
    V4,
    V6,
}

fn route(ip_type: IpAddrKind) {}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(four);
    route(six);
}

将目前的 IpAddrKind 枚举搭配结构体使用看看吧!程序如下:

enum IpAddrKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

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

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

程序第 6 行到第 9 行,定义了一个新的结构体 IpAddr,用来表示一个 IP 地址种类和地址。种类的类型即为 IpAddrKind 枚举,而地址则使用字符串类型来保存。这样的写法并没有什么问题,但我们可以再写得更精简一点,只用一个枚举,不搭配其它结构体,就能够完成一样的事情。程序如下:

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

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

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

在定义枚举的变体时,可以在变体名称后面加上小括号 () 来定义其携带其它值的字段,类似元组结构体的语法。每个枚举的变体可以携带的值,数量并没有限制。例如:

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

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

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

以上程序将 V4 从保存一个字符串改成保存 4 个 8 比特的无号整数。虽然 home 和 loopback 变量都是属于 IpAddr 类型,但它们携带的值却可以是不同数量、不同类型。

接着再来看看其它枚举的例子。请看以下程序:

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

这个 Message 枚举有四个变体,能用来处理四种不同类型的消息。这里要注意的是变体 Move 定义的方式,它的语法类似结构体,使用大括号 {},且拥有字段名称。如果把 Message 枚举的四个变体转成结构体的写法的话,程序如下:

struct QuitMessage; // unit-like struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

使用结构体的方式改写原先的 Message 枚举后,QuitMessage、MoveMessage、WriteMessage 和 ChangeColorMessage 就都不是同一个类型了。

枚举的变体跟结构体很像,除了可以定义数据字段之外,它也可以使用 impl 关键字来定义方法和关联函数。如以下程序:

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

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

fn main() {
    let m = Message::Write(String::from("hello"));

    m.call();
}

impl 关键字搭配枚举所实作出来的方法适用于该枚举底下的所有变体。也就是说,以上程序,不论是 Message::Write、Message::Quit、Message::Move 还是 Message::ChangeColor 的实体,都可以使用 call 方法。在 call 方法可以利用 self 参数对实体本身做「型样匹配」(pattern matching)来决定要运行什么程序,这个部份将在这个章节后半部做介绍。

先来介绍一下 Rust 编程语言提供的一个常用的枚举类型 Option。Option 枚举和 Result 枚举都是在定义 Rust 编程语言的方法或是函数时,常使用的类型。Result 枚举用来表示函数或是方法有没有运行成功,而 Option 枚举则可以用来包裹函数或是方法的回传值。Result 枚举的 Ok 变体不是就可以包裹回传值了吗?为什么还要用 Option 枚举呢?

在许多编程语言中有 null 或 nil 关键字可以使用,即「空值(没有这个值)」的概念。而在 Rust 编程语言中,并不能直接使用 null 或 nil 关键字来代表「空值」。可是在很多种情况下,函数或是方法虽然在逻辑上是运行成功的,但是因某些条件的关系而不会回传值出来,这时候要怎么让 Rust 的函数或是方法回传「空值」呢?

Option 枚举就是为了表示「空值」而存在的,其定义如下:

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

<T> 是泛型的语法,这个在之后的章节会介绍。现在只要知道 Option 枚举有 Some 和 None 两种变体,且 Some 可以包裹其他类型的值,而 None 就是表示「空值」啦!实体化 Option 枚举的方式如下:

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

let absent_number: Option<i32> = None;

在使用 Result 枚举和 Option 枚举的变体时不需要撰写 Result:: 和 Option:: 来指定使用哪个枚举下的变体,因为 Result 枚举和 Option 枚举的变体都已经被包含在 std::prelude 模块中,会自动被引用进目前程序的 scope。

另外,如果想要用类似的方式实体化 Result 枚举的话,必须要先定义好 Result 的泛型类型,才能通过编译,因为 Result 的泛型有两个参数,各自是 Ok 和 Err 变体所包裹的值的类型。Result 枚举的定义如下:

enum Result<T, E> {
   Ok(T),
   Err(E),
}

举例来说:

let ok_number = Ok(5);
let err_string = Err("a string");

以上程序会编译错误,因为直接实体化 Ok(5),只能推测 T 是 i32,并不能推测 E 的类型;直接实体化 Err("a string"),也只能推测 E 是 &str,并不能推测 T 的类型。

所以要明确定义 Result 枚举的类型所用的泛型类型,才可以通过编译,程序如下:

let ok_number: Result<i32, &str> = Ok(5);
let err_string: Result<i32, &str> = Err("a string");

到这里如果还是不懂 <> 所表示的「泛型」到底是什么也没关系,后面的章节会有详细的介绍。

接下来介绍一下 match 关键字吧!虽然我们之前有用过,但并没有将它彻底地了解。match 关键字可以用来做任何值的「型样匹配」(pattern matching),早在练习我们写猜数字程序的时候就已使用过,复习一下,程序如下:

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: i32 = match guess.trim().parse() {
            Ok(-1) => {
                println!("Bye bye!");
                break;
            }
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

再举一个新的例子,请看以下代码:

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

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

这个程序中的 value_in_cents 函数可以将 Coin 变体的实体转成其对应的一个 32 比特的无号整数。match 和 if 关键字不同的地方在于:if 关键字必须使用布尔值来进行流程判断;而 match 关键字则可以判断任何类型的值,经常与枚举类型的值一同使用。

以 match 关键字来匹配 Option 枚举的值来举例:

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

以上程序,plus_one 函数可以接受一个 Option<i32> 的值。如果传入的值是 None 的实体的话,就回传 None;如果传入的值是 Some 的实体的话,就将传入的 Some 实体包裹在第一个参数的值加一之后,再用新的 Some 包裹起来回传。

match 关键字有一个很重要的特性,那就是它必须将要判断的值的所有可能都列在「arm」,如果有遗漏,程序就会编译失败。举例来说:

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

以上程序会编译失败,因为 x 的类型为 Option<i32>,它可能的值除了 Some(i32) 外,还有 None,但是 match 中并未有 arm 去判断当 x 为 None 时要做的事情。

当然,如果每次使用 match 关键字时都要将所有可能的值都写成 arm 会很麻烦,如果我们要判断的值是 u8 类型,那不就要写 256 (28)条 arm 吗?别紧张,对于我们想要统一用一样的方式处理的其它值,可以使用底线 _ 作为匹配样本。举例来说:

let some_u8_value = 0u8;

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

_ 的概念就像是 if 的 else,当 _ 先前的 arm 都匹配失败时,就会运行 _ 的 arm。也就是说,_ 的 arm 应该放在最后一个,如果安插在 arm 跟 arm 之间,编译时将会出现警告消息。

再来看一个 match 关键字和 Option 枚举的例子:

let some_u8_value = Some(0u8);

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

以上程序的目的是要判断当 some_u8_value 值为 Some 的实体,且包裹着 3 时,就印出 three,否则不做任何事情。在很多时候,我们在意的只有 Some 变体所包裹的值,而不想去理会当 Option 枚举的实体如果是 None 时应该要做什么事。Rust 编程语言另外还有一种语法能使用,也就是 if let 语法。以上程序,可以使用 if let 语法改写为:

let some_u8_value = Some(0u8);

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

先不要去想 match 关键字写的程序叙述要怎么转成 if let 语法,而是去想如果我们要用之前学到的 if 关键字来判断 some_u8_value 变量的值是不是 Some(3) 的话要怎么写,最直觉的代码如下:

fn main() {
    let some_u8_value = Some(0u8);

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

这样的程序是可以编译并运行的哦!但是如果我们只是要判断 some_u8_value 变量的值是不是 Some 的实体的话,用 if 关键字要怎么做到呢?拿刚才的 plus_one 函数来修改看看:

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

以上程序会编译错误,因为 i 被当成是要作为参数传入 Some 变体的变量了,而不是要代替 Some 实体第一个参数所包裹的值,因此编译器会认为 i 没有事先声明出来,产生编译错误。

为了要让编译器了解这边的 i 是要代替 Some 实体第一个参数所包裹的值,我们必须使用 if let 语法来改写。如下:

fn plus_one(x: Option<i32>) -> Option<i32> {
    if let Some(i) = x {
        Some(i + 1)
    } else {
        None
    }
}

除了在 if 关键字后面加上 let 关键字外,还需要将判断值是否相等的 == 改为指派值用的 =。请注意 = 是将右边的值指派给左边的变量,因此 if let Some(i) = x 不能够写成 if let x = Some(i)。

当然就和一般的 if 关键字组成的程序叙述一样,if let 和 else if 也是可以一起使用的。如下:

fn test(x: Option<i32>) -> Option<i32> {
    if Some(3) == x {
        Some(0)
    } else if Some(4) == x {
        Some(1)
    } else if let Some(5) = x {
        Some(2)
    } else if let Some(i) = x {
        Some(i + 1)
    } else {
        None
    }
}

if let 语法就是原本的 if 关键字所组成的程序叙述再加上 let 关键字的特殊用法,不要用 match 关键字去想它会比较容易理解。如果想单独将 let 关键字和枚举实体拆出来使用的话,是不行的。举例来说:

let Some(i) = Some(3);

我们预期会声明出一个变量 i 并指派 3 给它,然而这进程式会编译错误。

除了 if let 语法之外,还有 while let 语法。举例来说:

fn main() {
    let mut stack = Vec::new();

    stack.push(1);
    stack.push(2);
    stack.push(3);

    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

程序第 8 行开始的 while 循环,会在 stack 变量的 Vec 实体调用 pop 方法的回传值为 Some 变体的时候,才继续运行循环。

if let 或是 while let 语法也与 match 关键字一样,可以使用 | 字符,来表示「或」(or)的逻辑。举例来说:

enum Creature {
    Crab(String),
    Lobster(String),
    Person(String),
}

fn main() {
    let state = Creature::Crab(String::from("Ferris"));

    if let Creature::Crab(name) | Creature::Person(name) = state {
        println!("This creature's name is: {name}");
    }
}

事实上,型样匹配不只限于在 match 关键字、if let 或是 while let 语法才能使用。我们使用 let 关键字声明变量,如 let x = 5、let (x, y) = (1, 2),甚至是函数或方法的参数,如 (x, y): (i32, i32),或是 for 循环,其实也都是在做型样匹配哦!举例来说:

fn main() {
    let a = 5;
    let b = 6;

    let (x, y) = (a, b);

    println!("{x}");
    println!("{y}");

    let tuple = (10, 11);

    let list = vec![1, 2, 3];

    for (v, &i) in list.iter().enumerate() {
        println!("{i}: {v}");
    }

    f(tuple);
}

fn f((x, y): (i32, i32)) {
    println!("{x}");
    println!("{y}");
}

以上程序运行结果如下:

5
6
1: 0
2: 1
3: 2
10
11

Rust 编程语言将型样匹配分为「可辩驳」(refutable)和「不可辩驳」(irrefutable)两种,let x = 5、let (x, y) = (1, 2)、(x, y): (i32, i32) 这样的用法都是属于「不可辩驳」的型样匹配,因为不论是 x 和 y 都可以是任何值,匹配一定可以成功。而 if let Some(x) = a_value 这种的匹配方式为「可辩驳」的,因为 a_value 实际的值可能为 Some 变体,也可能为 None 变体,有可能会匹配失败。

函数或方法的参数、let 关键字和 for 循环,只能支持「不可辩驳」的型样匹配,if let 和 while let 语法则是用于「可辩驳」的型样匹配(使用「不可辩驳」的型样时,编译器会发出警告),match 的 arm,可以同时支持「不可辩驳」和「可辩驳」的型样匹配。

match 关键字的型样匹配,还可以有一些特殊的变化。例如我们可以在每个 arm 要匹配的样本中,使用 | 字符,来表示「或」(or)的逻辑。举例来说:

let x = 1;

match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("anything"),
}

也可以同时使用多个 | 字符。举例来说:

let x = 5;

match x {
    1 | 2 | 3 | 4 | 5 => println!("one through five"),
    _ => println!("something else"),
}

以上程序,由于 1 到 5 是连续的整数数值范围,我们也可以在型样匹配的样本中使用先前提过的 .. 和 ..= 范围语法(前者属于 exclusive_range_pattern 特色,由于其还在实验阶段,所以需加上 #![feature(exclusive_range_pattern)],并使用 Rust 的 nightly 版本来编译程序)。举例来说:

let x = 5;

match x {
    1..= 5 => println!("one through five"),
    _ => println!("something else"),
}

型样匹配除了可以用在枚举之外,一般的结构体也能使用,可以快速地「解开」结构体。举例来说:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x, y } = p;

    println!("{x}");
    println!("{y}");
}

以上程序运行结果如下:

0
7

再举一个例子:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let points = vec![
        Point { x: 0, y: 0 },
        Point { x: 1, y: 5 },
        Point { x: 10, y: -3 },
    ];

    let mut sum_of_squares = 0;

    for Point { x, y } in points.iter() {
        sum_of_squares += x * x + y * y;
    }

    println!("{sum_of_squares}");
}

运行结果如下:

135

我们也可以对结构体使用可辩驳的型样匹配。举例来说:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x: 0, y } => {
            println!("x is zero, y is {y}");
        }
        Point { x, y } => ()
    }
}

如果不想要直接使用结构体的字段名称作为变量名称的话,也可以直接在 : 字符后面定义该字段的值要匹配到的变量名称。举例来说:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x: 0, y: y_var } => {
            println!("x is zero, y is {y_var}");
        }
        Point { x, y } => ()
    }
}

那么如果我们想要对结构体使用可辩驳的型样匹配,同时又想使用自己的变量名称的话,要怎么做呢?那就是在变量名称后面使用 @ 字符来串接要匹配的值。举例来说:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x: 0, y: y_var @ 5..=7 } => {
            println!("x is zero, y is {y_var}");
        }
        Point { x, y } => ()
    }
}

当然也可以让多个结构体和枚举复合使用,举例来说:

struct Point {
    x: i32,
    y: i32,
}


fn main() {
    let a: (Option<Point>, Option<Point>) = (Some(Point { x: 3, y: 4 }), None);

    if let (Some(Point { x, y }), None) = a {
        println!("{x}");
        println!("{y}");
    }
}

以上程序运行结果如下:

3
4

底线 _ 其实不只能够被单独使用在匹配样本中,它的匹配方式就相当于 x、y 这样的变量,只是 _ 在匹配完成后就会忽略掉匹配成功的值了。举例来说:

let v = Some(5);

match v {
    Some(_) => {
        println!("Some");
    }
    _ => {
        println!("None");
    }
}

Some(_) 和 Some(x) 可以说是完全一样的匹配样本,只是如果使用 Some(_) 来匹配的话,就不会有一个实际的变量来保存匹配到的值。如果我们将以上程序的 Some(_) 改为 Some(x) 的话:

let v = Some(5);

match v {
    Some(x) => {
        println!("Some");
    }
    _ => {
        println!("None");
    }
}

程序在编译时将会出现 unused variable: `x` 的警告消息。不管在哪,如果我们声明了变量却完全没去使用的话,Rust 的编译器都会出现这个消息。如果想要让编译器不出现这个警告消息的话,可以让变量的名称以底线 _ 开头,如下:

let v = Some(5);

match v {
    Some(_x) => {
        println!("Some");
    }
    _ => {
        println!("None");
    }
}

这样一来编译器就不会出现 unused variable: `x` 的警告消息了!

我们除了能用 _ 在型样匹配时忽略不想要的值之外,也可以使用 .. 语法来直接忽略掉数据结构中所有剩下来的值。要注意这边的 .. 语法并不是范围语法哦!举例来说:

struct Point {
    x: i32,
    y: i32,
    z: i32,
}

fn main() {
    let p = Point { x: 0, y: 7, z: 9 };

    let Point { x, .. } = p;

    println!("{x}");
}

以上程序运行结果如下:

0

再举一个例子:

fn main() {
    let t = (3, 4, 5, 6, 7, 8);

    let (x, y, ..) = t;
    
    println!("{x}");
    println!("{y}");
}

以上程序运行结果如下:

3
4

当 .. 语法用在元组的时候,其位置不一定要放在最右边,但是只能够出现一次。举例来说:

fn main() {
    let t = (3, 4, 5, 6, 7, 8);

    let (.., x, y) = t;

    println!("{x}");
    println!("{y}");
}

以上程序运行结果如下:

7
8

再举一个例子:

fn main() {
    let t = (3, 4, 5, 6, 7, 8);

    let (x, y, .., z) = t;

    println!("{x}");
    println!("{y}");
    println!("{z}");
}

以上程序运行结果如下:

3
4
8

接着来谈谈型样匹配时的拥有权吧!先看以下的程序:

fn main() {
    let robot_name = Some(String::from("Magic Len"));

    match robot_name {
        Some(name) => println!("Found a name: {name}"),
        None => (),
    }
}

这个程序会编译成功,并且在屏幕上印出:

Found a name: Magic Len

然而,如果我们在最后添加一些程序进去,来使用 robot_name 变量的话,会发生什么事呢?程序如下:

fn main() {
    let robot_name = Some(String::from("Magic Len"));

    match robot_name {
        Some(name) => println!("Found a name: {name}"),
        None => (),
    }

    println!("robot_name is: {robot_name:?}");
}

我们添加的程序第 9 行会编译失败,因为 robot_name 变量原本的值,已经移动给程序第 5 行 match 的 arm 所匹配好的变量 name 了。为了解决在型样匹配过程中拥有权转移的问题,我们可以在匹配样本的变量前使用 ref 关键字来取得匹配到的值的参考并指派给变量,而不是直接将匹配到的值的本身指派给变量。至于为什么不使用 & 就好,那是因为 & 在型样匹配中代表的意义是「匹配参考类型」,而不是「取得值的参考」。

举例来说:

fn main() {
    let s = String::from("Hello");

    let n = Some(5);

    let v = Some(&n);

    match v {
        Some(&Some(a)) => {
            println!("&Some!")
        }
        _ => {}
    }
}

用 & 来做型样匹配其实看起来蛮奇怪,虽然现在的 Rust 在做类似的型样匹配时可以省略 &,但在早期的 Rust 版本,& 却是必要的。不过总之,就是因为 & 在型样匹配中已经有它既定的用途了,因此我们需要使用 ref 关键字来代替用来取得参考的 &。

将刚才的 Robot Name,加上 ref 关键字,改写如下:

fn main() {
    let robot_name = Some(String::from("Magic Len"));

    match robot_name {
        Some(ref name) => println!("Found a name: {name}"),
        None => (),
    }

    println!("robot_name is: {robot_name:?}");
}

程序第 5 行的变量 name,类型变成 &String,并不会更动到原先 String 结构实体的拥有者,因此程序可以通过编译。运行结果如下:

Found a name: Magic Len
robot_name is: Some("Magic Len")

如果要使用可变参考,也可以让 ref 关键字和 mut 关键字搭配使用。例如:

fn main() {
    let mut robot_name = Some(String::from("Magic Len"));

    match robot_name {
        Some(ref mut name) => {
            println!("Found a name: {name}");

            name.push_str(" (checked)");
        }
        None => (),
    }

    println!("robot_name is: {robot_name:?}");
}

运行结果如下:

Found a name: Magic Len
robot_name is: Some("Magic Len (checked)")

另外,match 关键字的型样匹配还有「匹配守卫」(match guard)的用法,需要让 match 的 arm,搭配 if 关键字使用。利用这个匹配守卫语法,我们可以让 arm 增加一些匹配条件。当匹配守卫的条件参数运算结果为 true,这个 arm 就会匹配成功,运行其所对应的程序区块。举例来说:

let num = Some(4);

match num {
    Some(x) if x < 5 => println!("less than five: {x}"),
    Some(x) => println!("{x}"),
    None => (),
}

前面有提到,match 关键字必须将要判断的值的所有可能都列在「arm」,如果我们想要让 match 表达式在成功完成某个匹配后回传 true,如果不匹配就回传 false 的话,程序写起来会像是这样。例如:

let x = 5;

let in_range = match x {
    1..=5 | 25..=99 => true,
    _ => false,
};

我们可以使用 matches! 宏将以上程序化简如下:

let x = 5;

let in_range = matches!(x, 1..=5 | 25..=99);

总结

这章节我们学会了如何使用枚举来撰写 Rust 程序,并且也深入了解了 Rust 编程语言的型样匹配了。我们现在的 Rust 程序功力已经足够写出各式各样的运算程序(单线程限定),可以去找一些算法的题目来练习看看。接下来的章节会介绍模块(mod)的用法,将我们写好的程序包装起来给别人使用!

下一章:模块。