Rust语言从入门到精通系列 – 强大且灵活的匹配模式

Rust 是一门现代化的系统编程言语，它具有高性能、内存安全和并发性等特点。Rust 的语法规划十分优异，其间 match 句子是一种十分强大的言语特性。match 句子能够让咱们依据不同的匹配形式履行不同的代码，这在处理杂乱的逻辑时十分有用。在本教程中，咱们将深化了解 Rust 的 match 句子，包含根底用法、进阶用法和实践经验等方面。

根底用法

match 句子是 Rust 中的一种操控流句子，它能够让咱们依据不同的形式匹配履行不同的代码。match 句子的基本语法如下：

match value {
    pattern1 => {
    // code1
    }
    pattern2 => {
    // code2
    }
    _ => {
    // 没有任何匹配
    }
}

其间，value 是要匹配的变量，pattern 是匹配形式，=>后边是要履行的代码块。假如 value 匹配了某个形式，就会履行对应的代码块。假如 value 没有匹配任何形式，就会履行默许的代码块（即_ => {…}）。

接下来，咱们将经过一些示例来介绍 match 句子的根底用法。

匹配整数

fn main() {
    let x = 1;
    match x {
        1 => println!("x is one"),
        2 => println!("x is two"),
        _ => println!("x is not one or two"),
    }
}
//  x is one

在这个示例中，咱们界说了一个整数变量 x，并运用 match 句子匹配它。假如 x 等于 1，就会履行第一个代码块，输出”x is one”；假如 x 等于 2，就会履行第二个代码块，输出”x is two”；假如 x 不等于 1 或 2，就会履行默许的代码块，输出”x is not one or two”。

匹配枚举类型

enum Color {
    Red,
    Green,
    Blue,
}
let color = Color::Green;
match color {
    Color::Red => println!("The color is red"),
    Color::Green => println!("The color is green"),
    Color::Blue => println!("The color is blue"),
}

在这个示例中，咱们界说了一个枚举类型 Color，并将变量 color 赋值为 Color::Green。然后，咱们运用 match 句子匹配 color。假如 color 等于 Color::Red，就会履行第一个代码块，输出”The color is red”；假如 color 等于 Color::Green，就会履行第二个代码块，输出”The color is green”；假如 color 等于 Color::Blue，就会履行第三个代码块，输出”The color is blue”。

匹配元组

let point = (1, 2);
match point {
    (0, 0) => println!("The point is at the origin"),
    (_, 0) => println!("The point is on the x-axis"),
    (0, _) => println!("The point is on the y-axis"),
    (x, y) => println!("The point is at ({}, {})", x, y),
}

在这个示例中，咱们界说了一个元组变量 point，并运用 match 句子匹配它。假如 point 等于(0, 0)，就会履行第一个代码块，输出”The point is at the origin”；假如 point 的第二个元素等于 0，就会履行第二个代码块，输出”The point is on the x-axis”；假如 point 的第一个元素等于 0，就会履行第三个代码块，输出”The point is on the y-axis”；否则，就会履行第四个代码块，输出”The point is at ({}, {})”。

匹配规模

let age = 20;
match age {
    0..=17 => println!("You are a minor"),
    18..=64 => println!("You are an adult"),
    _ => println!("You are a senior"),
}

在这个示例中，咱们界说了一个整数变量 age，并运用 match 句子匹配它。假如 age 的值在 0 到 17 之间，就会履行第一个代码块，输出”You are a minor”；假如 age 的值在 18 到 64 之间，就会履行第二个代码块，输出”You are an adult”；否则，就会履行默许的代码块，输出”You are a senior”。

匹配引证

let x = 1;
let y = &x;
match y {
    &1 => println!("The value is one"),
    _ => println!("The value is not one"),
}

在这个示例中，咱们界说了一个整数变量 x 和一个指向 x 的引证 y。然后，咱们运用 match 句子匹配 y。由于 y 是一个引证，所以咱们需求在形式中运用&符号来匹配它。假如 y 指向的值等于 1，就会履行第一个代码块，输出”The value is one”；否则，就会履行默许的代码块，输出”The value is not one”。

匹配护卫

let x = 5;
match x {
    n if n < 0 => println!("The value is negative"),
    n if n > 10 => println!("The value is greater than 10"),
    _ => println!("The value is between 0 and 10"),
}

在这个示例中，咱们界说了一个整数变量 x，并运用 match 句子匹配它。在形式中，咱们运用 if 句子添加了一个护卫条件。假如 x 小于 0，就会履行第一个代码块，输出”The value is negative”；假如 x 大于 10，就会履行第二个代码块，输出”The value is greater than 10″；否则，就会履行默许的代码块，输出”The value is between 0 and 10″。

进阶用法

除了上面介绍的根底用法，match 句子还有一些进阶用法，能够让咱们愈加灵活地运用它。接下来，咱们将介绍 match 句子的一些进阶用法，并经过示例来演示它们的用法。

运用|匹配多个形式

let x = 1;
match x {
    1 | 2 => println!("The value is one or two"),
    _ => println!("The value is not one or two"),
}

在这个示例中，咱们界说了一个整数变量 x，并运用 match 句子匹配它。在形式中，咱们运用|符号来匹配多个形式。假如 x 等于 1 或 2，就会履行第一个代码块，输出”The value is one or two”；否则，就会履行默许的代码块，输出”The value is not one or two”。

运用..=匹配规模

let age = 20;
match age {
    0..=17 => println!("You are a minor"),
    18..=64 => println!("You are an adult"),
    _ => println!("You are a senior"),
}

在这个示例中，咱们界说了一个整数变量 age，并运用 match 句子匹配它。在形式中，咱们运用..=符号来匹配规模。假如 age 的值在 0 到 17 之间，就会履行第一个代码块，输出”You are a minor”；假如 age 的值在 18 到 64 之间，就会履行第二个代码块，输出”You are an adult”；否则，就会履行默许的代码块，输出”You are a senior”。

运用@绑定变量

let x = Some(5);
match x {
    Some(n @ 1..=10) => println!("The value is between 1 and 10: {}", n),
    Some(n @ 11..=20) => println!("The value is between 11 and 20: {}", n),
    Some(_) => println!("The value is not between 1 and 20"),
    None => (),
}

在这个示例中，咱们界说了一个 Option 类型的变量 x，并运用 match 句子匹配它。在形式中，咱们运用@符号来绑定一个变量。假如 x 是一个 Some 类型，而且它的值在 1 到 10 之间，就会履行第一个代码块，输出”The value is between 1 and 10″；假如 x 是一个 Some 类型，而且它的值在 11 到 20 之间，就会履行第二个代码块，输出”The value is between 11 and 20″；假如 x 是一个 Some 类型，但它的值不在 1 到 20 之间，就会履行第三个代码块，输出”The value is not between 1 and 20″；假如 x 是一个 None 类型，就不会履行任何代码。

运用_疏忽形式

let x = Some(5);
match x {
    Some(_) => println!("The value is some"),
    None => println!("The value is none"),
}

在这个示例中，咱们界说了一个 Option 类型的变量 x，并运用 match 句子匹配它。在形式中，咱们运用_符号来疏忽形式。假如 x 是一个 Some 类型，就会履行第一个代码块，输出”The value is some”；假如 x 是一个 None 类型，就会履行第二个代码块，输出”The value is none”。

运用 if let 简化形式匹配

let x = Some(5);
if let Some(n) = x {
    println!("The value is {}", n);
} else {
    println!("The value is None");
}

在这个示例中，咱们界说了一个 Option 类型的变量 x，并运用 if let 句子匹配它。假如 x 是一个 Some 类型，就会履行 if 句子块，输出”The value is x”；假如 x 是一个 None 类型，就会履行 else 句子块，输出”The value is None”。运用 if let 句子能够简化形式匹配的代码，使代码愈加明晰和简练。

运用 while let 遍历迭代器

let mut v = vec![1, 2, 3];
while let Some(n) = v.pop() {
    println!("{}", n);
}

在这个示例中，咱们界说了一个整数数组 v，并运用 while let 句子遍历它的元素。在 while let 句子中，咱们运用 pop()方法从数组中依次取出元素，并将它们绑定到变量 n 中。假如数组中还有元素，就会履行 while 句子块，输出元素的值；否则，就会退出 while 循环。运用 while let 句子能够方便地遍历迭代器或者其他可迭代对象。

实践经验

在实践开发中，咱们经常需求运用 match 句子来处理杂乱的逻辑。以下是一些实践经验，能够帮助咱们更好地运用 match 句子。

给每个分支加上花括号

在 match 句子中，每个分支的代码块一般都比较杂乱，因而咱们应该给每个分支加上花括号，以便更好地阅读和维护代码。例如：

fn main() {
    let x = 1;
    match x {
        1 => {
            println!("The value is one");
            println!("This is a long message");
        }
        2 => {
            println!("The value is two");
        }
        _ => {
            println!("The value is not one or two");
        }
    }
}
// The value is one
// This is a long message

运用_疏忽不需求的变量

在 match 句子中，咱们能够运用_符号来疏忽不需求的变量。这样能够简化代码，而且让代码愈加明晰。例如：

let x = (1, 2);
match x {
    (1, _) => println!("The first element is 1"),
    (_, 2) => println!("The second element is 2"),
    _ => (),
}

在这个示例中，咱们运用_符号来疏忽第二个元素，因为咱们只关怀第一个元素是否等于 1。

运用 if let 简化形式匹配

在某些情况下，咱们只需求匹配一个形式，而不需求处理其他形式。此时，咱们能够运用 if let 句子来简化形式匹配的代码。例如：

let x = Some(5);
if let Some(n) = x {
    println!("The value is {}", n);
}

在这个示例中，咱们只需求匹配 Some 类型的值，而不需求处理 None 类型的值。因而，运用 if let 句子能够让代码愈加简练和明晰。

运用 while let 遍历迭代器

在遍历迭代器时，咱们能够运用 while let 句子来依次取出元素，并进行处理。例如：

fn main() {
    let v = vec![1, 2, 3];
    for n in &v {
        println!("{}", n);
    }
    let mut v = vec![1, 2, 3];
    while let Some(n) = v.pop() {
        println!("{}", n);
    }
}

在这个示例中，咱们运用 for 循环和 while let 句子来遍历整数数组 v 的元素。运用 while let 句子能够让代码愈加简练和明晰。

总结

match 句子是 Rust 中十分强大的言语特性，它能够让咱们依据不同的匹配形式履行不同的代码。在本教程中，咱们介绍了 match 句子的根底用法、进阶用法和实践经验等方面。经过学习本教程，信任读者已经掌握了 match 句子的基本用法，并能够在实践开发中灵活运用它。