Rust 模式匹配

模式匹配是一种匹配值结构并将变量绑定到其部分的方法。它是处理 Rust 程序中的数据和控制流的强大方式。

在模式匹配方面，我们通常使用 match 表达式。

match 表达式的语法是

match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
}

在这里，PATTERN => EXPRESSION 被称为模式，这是 Rust 中的一种特殊语法，通常与 match 关键字一起使用。

匹配 Rust 中的变量

我们可以针对变量的值进行模式匹配。如果我们的代码想根据特定值采取某些操作，这将非常有用。例如：

fn main() {
    let x = 2;

    // use of match expression to pattern match against variable x
    match x {
        1 => println!("x is 1"),
        2 => println!("x is 2"),
        _ => println!("x is something else"),
    }
}

输出

x is 2

在这里，我们使用 match 表达式匹配 x。在 match 体中，我们用值 1、2 和 _ 进行了模式匹配。

1 => println!("x is 1"),
2 => println!("x is 2"),
_ => println!("x is something else"),

由于 x 的值为 2，匹配的模式是

2 => println!("x is 2")

因此，屏幕上会打印 x is 2。

请注意，我们也匹配下划线 _。_ 在模式匹配中具有特殊含义，如果所有其他模式都不匹配，它将默认为 _。

注意：match 体（也称为 match arms）应始终确保所有可能的情况都得到处理。如果所有可能的情况都没有得到处理，Rust 程序将无法编译。

匹配 Rust 中的枚举

模式匹配广泛用于匹配枚举变体。例如：

fn main() {
    enum Color {
        Red,
        Green,
        Blue,
    }

    let my_color = Color::Green;

    // use of match expression to match against an enum variant
    match my_color {
        Color::Red => println!("The color is red"),
        Color::Green => println!("The color is green"),
        Color::Blue => println!("The color is blue"),
    }
}

输出

The color is green

在这里，我们在 match 表达式中创建了一个模式来匹配所有枚举变体。

Color::Red => println!("The color is red"),
Color::Green => println!("The color is green"),
Color::Blue => println!("The color is blue"),

由于 my_color 的值为 Color::Green，它匹配的模式是

Color::Green => println!("The color is green"),

因此，屏幕上会打印 The color is green。

匹配 Rust 中的 Option 和 Result 类型

模式匹配最常见的情况是与 Option 和 Result 枚举类型一起使用。Option 和 Result 类型都有两个变体。

Option 类型具有

• None → 表示失败且没有值
• Some(T) → 类型为 T 的值

Result 类型具有

• Ok(T) → 操作成功，值为 T
• Err(E) → 操作失败，并带有错误 E

让我们通过示例了解如何对这些类型使用模式匹配。

示例：匹配 Rust 中的 Option 类型

fn main() {
    let my_option: Option<i32> = Some(222);
    
    // use of match expression to match Option type
    match my_option {
        Some(value) => println!("The option has a value of {}", value),
        None => println!("The option has no value"),
    }
}

输出

The option has a value of 222

在此示例中，my_option 是一个 Option 类型，其中包含一个带 i32 值的 Some 变体或一个 None 变体。

match 表达式将 my_option 的值与 Some 和 None 变体进行比较，并将 Some 变体的值绑定到 value 变量。

当找到匹配项时，将执行相应的代码块。

Some(value) => println!("The option has a value of {}", value),

因此，屏幕上会打印 The option has a value of 222。

示例：匹配 Rust 中的 Result 类型

fn main() {
    let my_result: Result<i32, &str> = Ok(100);

    // use of match expression to match Result type
    match my_result {
        Ok(value) => println!("The result is {}", value),
        Err(error) => println!("The error message is {}", error),
    }
}

输出

The result is 100

在此示例中，my_result 是一个 Result 类型，其中包含一个带 i32 值的 Ok 变体，或一个带有 &str 类型错误消息的 Err 变体。

match 表达式将 my_result 的值与 Ok 和 Err 变体进行比较，并将 Ok 变体的值绑定到 value 变量，或将 Err 变体的值绑定到 error 变量。

Ok(value) => println!("The result is {}", value),
Err(error) => println!("The error message is {}", error),

当找到匹配项时，将执行相应的代码块。

Ok(value) => println!("The result is {}", value),

因此，屏幕上会打印 The result is 100。

Rust 中的 if let 表达式

Rust 中的 if let 表达式是只有一个模式/臂要匹配的 match 表达式的简写。

它允许我们匹配一个值，然后仅当匹配成功时才执行代码。

fn main() {
    let my_option: Option<i32> = Some(222);

    // use of if let expression on the Option type
    if let Some(value) = my_option {
        println!("The option has a value of {}", value);
    } else {
        println!("The option has no value");
    }
}

输出

The option has a value of 111

在这里，if let 表达式正在匹配 my_option 变量，并将 Some 变体的值绑定到 value 变量。

如果匹配成功，将执行 if 块内的代码。如果匹配不成功，将执行 else 块内的代码。

Rust 中模式匹配的常见用例

正如您所见，模式匹配在许多情况下都很有用。模式匹配的一些常见用例包括：

• 匹配任何值，例如整数
• 匹配枚举、结构体或元组
• 表达条件逻辑
• 解构数据结构或在 for 循环中解构迭代器元素
• 使用 Result 和 Option 类型进行错误处理