【Rust 基础篇】Rust 匹配（Pattern Matching）

2023-10-12 10:36:22 浏览数 (1)

导言

在 Rust 中，匹配（Pattern Matching）是一种强大的语言特性，它允许我们根据不同的模式来执行不同的操作。匹配可以用于多种情况，例如处理枚举类型、解构元组和结构体、处理条件表达式等。本篇博客将详细介绍 Rust 中的匹配语法，并通过示例代码来说明其用法和优势。

一、基本用法

Rust 中的匹配使用 match 关键字。match 表达式由多个 arms 构成，每个 arm 包含一个模式和与之匹配时要执行的代码块。Rust 会按顺序逐个检查 arms，直到找到与输入匹配的模式，然后执行相应的代码块。以下是一个简单的示例：

代码语言：javascript复制
fn main() {
    let number = 3;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"),
    }
}

在上面的代码中，我们定义了一个变量 number 并将其赋值为 3。然后使用 match 表达式对 number 进行匹配。首先，Rust 检查第一个 arm，即模式 1，由于 number 不等于 1，因此不会执行该代码块。接着检查第二个 arm，即模式 2，同样不匹配。最后，Rust 检查第三个 arm，即模式 3，由于 number 等于 3，因此执行相应的代码块，输出 Three。

如果没有任何一个模式匹配成功，最后的 _（下划线）表示默认情况，相当于 default，会执行对应的代码块。

二、匹配枚举类型

在 Rust 中，枚举类型是一种自定义数据类型，可以用于表示具有不同变体的值。匹配是处理枚举类型的常见用法之一，通过匹配不同的枚举变体，我们可以根据实际情况执行不同的逻辑。

考虑以下示例，我们定义一个名为 Message 的枚举类型，它有三个不同的变体：Move、Write 和 ChangeColor：

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

现在，我们使用 match 表达式处理不同的 Message 变体：

代码语言：javascript复制
fn process_message(msg: Message) {
    match msg {
        Message::Move { x, y } => println!("Move to coordinates (x={}, y={})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to (r={}, g={}, b={})", r, g, b),
    }
}

fn main() {
    let msg1 = Message::Move { x: 10, y: 20 };
    let msg2 = Message::Write(String::from("Hello, world!"));
    let msg3 = Message::ChangeColor(255, 0, 0);

    process_message(msg1);
    process_message(msg2);
    process_message(msg3);
}

在上面的代码中，我们定义了一个 process_message 函数，接受一个 Message 枚举类型的参数 msg。在 match 表达式中，我们针对不同的枚举变体执行不同的逻辑。对于 Message::Move 变体，我们从模式中解构出 x 和 y，并打印出移动的坐标。对于 Message::Write 变体，我们直接打印出字符串。对于 Message::ChangeColor 变体，我们解构出 r、g 和 b，然后打印出颜色的 RGB 值。

在 main 函数中，我们创建了三个不同的 Message 变量，并将它们传递给 process_message 函数进行处理。根据不同的变体，我们可以执行不同的逻辑。

三、解构和匹配结构体

除了枚举类型，Rust 也支持解构和匹配结构体。结构体是一种自定义的数据类型，由多个字段组成。我们可以使用模式来解构结构体，并根据字段的值来执行相应的操作。

考虑以下示例，我们定义一个名为 Point 的结构体，表示二维平面上的点：

代码语言：javascript复制
struct Point {
    x: i32,
    y: i32,
}

现在，我们使用 match 表达式解构和匹配不同的 Point 结构体：

代码语言：javascript复制
fn process_point(point: Point) {
    match point {
        Point { x, y } => println!("Point coordinates: x={}, y={}", x, y),
    }
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = Point { x: -5, y: 15 };

    process_point(p1);
    process_point(p2);
}

在上面的代码中，我们定义了一个 process_point 函数，接受一个 Point 结构体类型的参数 point。在 match 表达式中，我们使用模式 Point { x, y } 解构出结构体的字段，并将其打印出来。

在 main 函数中，我们创建了两个不同的 Point 结构体变量，并将它们传递给 process_point 函数进行处理。通过模式匹配，我们可以方便地访问结构体的字段，并执行相应的操作。

四、使用 if let 简化匹配

在一些情况下，我们只关心某个特定的模式是否匹配，而不需要处理其他模式。此时，可以使用 if let 表达式来简化匹配过程。

考虑以下示例，我们定义一个名为 Value 的枚举类型，包含两个变体：Number 和 Text：

代码语言：javascript复制
enum Value {
    Number(i32),
    Text(String),
}

现在，我们使用 if let 表达式判断一个 Value 变量是否是 Number 类型：

代码语言：javascript复制
fn main() {
    let value = Value::Number(42);

    if let Value::Number(n) = value {
        println!("The value is a number: {}", n);
    } else {
        println!("The value is not a number");
    }
}

在上面的代码中，我们首先定义了一个 Value 变量 value，并将其赋值为 Value::Number(42)。然后使用 if let 表达式判断 value 是否是 Number 类型。如果是，我们解构出 n 并打印出结果；如果不是，则打印出相应的提示信息。

使用 if let 表达式可以使代码更加简洁和可读，尤其是在只关心某个特定模式的情况下。

五、匹配多个模式

在匹配过程中，有时我们希望同时匹配多个模式，并执行相同的代码块。Rust 提供了 | 运算符，可以在一个 arm 中同时匹配多个模式。

考虑以下示例，我们定义一个名为 number 的变量，并使用 match 表达式同时匹配多个模式：

代码语言：javascript复制
fn main() {
    let number = 42;

    match number {
        0 | 1 => println!("Zero or one"),
        2 | 3 | 4 => println!("Two, three, or four"),
        _ => println!("Other"),
    }
}

在上面的代码中，我们使用 match 表达式对变量 number 进行匹配。第一个 arm 中的模式 0 | 1 表示同时匹配 0 和 1，第二个 arm 中的模式 2 | 3 | 4 表示同时匹配 2、3 和 4。最后的 _ 表示默认情况，匹配其他任意值。

通过 | 运算符，我们可以简洁地同时匹配多个模式，避免重复的代码。

六、if let 和 while let

除了 match 表达式外，Rust 还提供了 if let 和 while let 表达式，用于在特定条件下进行模式匹配。

if let 表达式允许我们在条件为真时执行模式匹配，并执行相应的代码块。如果条件不匹配，则不执行任何操作。

while let 表达式类似于 if let，但是它允许我们在条件为真时重复执行模式匹配和相应的代码块。只要条件匹配，就会一直执行，直到条件不匹配为止。

以下是一个示例，演示了 if let 和 while let 表达式的用法：

代码语言：javascript复制
fn main() {
    let values = vec![Some(1), Some(2), None, Some(3)];

    for value in values {
        if let Some(num) = value {
            println!("Number: {}", num);
        } else {
            println!("None");
        }
    }

    let mut values = vec![Some(1), Some(2), None, Some(3)];
    while let Some(value) = values.pop() {
        if let Some(num) = value {
            println!("Number: {}", num);
        } else {
            println!("None");
        }
    }
}

在上面的代码中，我们首先定义了一个包含一些 Option 类型值的向量 values。通过 for 循环遍历 values，对于每个值，使用 if let 表达式判断是否是 Some 类型，如果是，则解构出内部的值 num 并打印出结果；如果是 None 类型，则打印出相应的提示信息。

接下来，我们定义了另一个向量 values，并使用 while let 表达式将其元素逐个弹出。只要向量中还有元素，并且弹出的元素是 Some 类型，就执行相应的代码块。

通过 if let 和 while let 表达式，我们可以根据特定的条件进行模式匹配，以更加灵活地处理不同的情况。

七、match 的穷尽性检查

在 Rust 中，match 表达式具有穷尽性检查的特性。这意味着编译器会检查我们的 match 表达式是否覆盖了所有可能的情况，确保没有遗漏。

如果某个 match 表达式没有穷尽性，编译器会给出警告，以防止出现潜在的错误。为了确保穷尽性，我们可以在 match 表达式的最后添加一个 _，表示默认情况。

以下是一个示例，演示了穷尽性检查的用法：

代码语言：javascript复制
enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Red;

    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        // 缺少 Color::Blue 分支
    }
}

在上面的代码中，我们定义了一个 Color 枚举类型，包含三个变体。然后使用 match 表达式对 color 进行匹配。我们提供了 Color::Red 和 Color::Green 的匹配分支，但是缺少了 Color::Blue 的匹配分支。

当我们尝试编译这段代码时，Rust 编译器会给出以下警告信息：

代码语言：javascript复制
warning: non-exhaustive patterns: `Color::Blue` not covered

警告提示我们的 match 表达式不具有穷尽性，因为没有覆盖到所有可能的情况。

为了解决这个问题，我们可以添加一个 _ 分支，或者显式处理所有的枚举变体。

总结

匹配是 Rust 中强大且灵活的语言特性，可以根据不同的模式执行不同的操作。本篇博客介绍了 Rust 中匹配的基本用法，包括对枚举类型、结构体的匹配，以及使用 if let 和 while let 简化匹配过程。同时，我们还探讨了 match 表达式的穷尽性检查，以确保匹配覆盖所有可能的情况。

通过灵活运用匹配，我们可以编写出更具表达力和可维护性的 Rust 代码。希望本篇博客对你理解和应用 Rust 中的匹配特性有所帮助！

rust matching 变量 函数 基础

0 人点赞