18模式和匹配

模式（pattern）是 Rust 中特殊的语法，它用来匹配类型中的结构，无论类型是简单还是复杂。

可以提供更多对程序控制流的支配权。

模式（pattern）由如下一些内容组合而成：

• 字面值
• 解构的数组、枚举、结构体或者元组
• 变量
• 通配符
• 占位符

这些部分描述了我们要处理的数据的形状，接着将一些值与模式相比较，如果数据符合这个形状，就可以进行相应的处理，如果不符合，与该模式相关的代码则不会运行。

本章涉及

• 所有可能使用模式的位置
• 可反驳（refutable） 与不可反驳 （irrefutable） 模式的区别
• 不同类型的模式语法

所有可能会用到模式的位置

match 分支

match 表达式的分支是模式常用的位置，

形式上，match表达式由以下几部分构成：

• match关键字，
• 用于匹配的值，
• 一个或多个分支，
  • 一个模式
  • 表达式（在值匹配分支的模式时运行的表达式）

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

match表达式必须是穷尽的（exhaustive），即所有可能的值都必须被考虑到。

确保覆盖每个可能的方式是在最后一个分支使用捕获所有的模式

• 即可以使用一个匹配任何值的命名变量，因为是无可反驳模式所以可以覆盖剩下所有的情况。

有一个特定的模式,_ 也可以匹配所有的情况，不过它从不绑定任何变量。

• 如果希望忽略任何未指定值得情况，使用 _ 很有用。
• 会在**[忽略模式中的值](# 忽略模式中的值)** 部分详细介绍_ 模式内容。

if let 条件表达式

if let 是只关心一种情况的 match 表达式的简写。

优点：

if let 表达式可以组合匹配 else if, else if let , else 等分支表达式，更灵活。

缺点：

if let 表达式的缺点在于其穷尽性没有被编译器检查，而match 表达式则检查了。

while let 条件循环

while let 是一个与 if let 结构类似的条件循环。

• 其实与 while 与 if 的性质一样。

它允许只要模式能匹配就一直进行 while 循环。

let mut stack = Vec::new();

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

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

for 循环

for 循环也可以获取一个模式。

在 for 循环中，模式是for 关键字直接跟随的值，

• 例如，for x in y 中的 x。

let v = vec!['a', 'b', 'c'];

// (index,value) 就是一个模式，
// 这里for循环中使用模式来解构元组
for (index, value) in v.iter().enumerate() {
    println!("{} is at index {}", value, index);
}

let 语句

let语句更为正式的样子如下：

let PATTERN = EXPRESSION;

例如，let x = 5;，这里 x 位于 pattern位置，变量名是形式特别朴素的模式。

我们将表达式与模式比较，并将匹配到的任何值绑定到变量x

let (x, y, z) = (1, 2, 3);

这里将一个元组与模式匹配。Rust 会比较值 (1, 2, 3) 与模式 (x, y, z) 并发现此值匹配这个模式。将会把 1 绑定到 x，2 绑定到 y 并将 3 绑定到 z。

注意：

如果模式中元素的数量不匹配元组中元素的数量，则整个类型不匹配，并会得到一个编译时错误。

函数参数

在函数中，函数参数变量名也是一个模式

fn foo(x: i32) {
    // 代码
}

上面例子中，x部分就是一个模式，类似于let语句。

// 这里 &(x,y) 就是一个模式，
// 值 &(3,5) 会匹配模式 &(x,y),这样x=3，y=5
fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("Current location: ({}, {})", x, y);
}

fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

Refutability（可反驳性）：模式是否会匹配失败

模式由两种形式：

• refutable（可反驳的）
  • 对某些可能的值进行匹配会失败的模式，被称为可反驳的（refutable）。
  • 例如：if let Some(x) = a_value，表达式中的Some(x)，如果a_value中的值是 None而不是Some,那么Some(x) 模式不能匹配，匹配失败。
• irrefutable（不可反驳的）
  • 能匹配任何传递的可能的值得模式，被称为不可反驳的（irrefutable）。
  • 例如：let x = 5;，语句中的x可以匹配任何值所以不可能会失败。

函数参数、let语句和for循环只能接受不可反驳的模式。

• 因为如果值不匹配，程序执行是无意义的。
• 在只接受不可反驳模式的地方使用可反驳模式，编译器在编译时会报错

if let和while let表达式被编译器限制为只能接受可反驳的模式。

• 因为这条件表达式的功能就是，根据成功或失败执行不同的操作。
  • 设计上就允许匹配失败，一定成功的情况就没有必要使用条件表达式了。
• 如果使用不可反驳的模式，编译器会给出一个警告（warning）

通常我们无需担心可反驳和不可反驳模式的区别，不过确实需要熟悉可反驳性的概念，这样当在错误信息中看到时就知道如何应对。遇到这些情况，根据代码行为的意图，需要修改模式或者使用模式的结构。

所有的模式语法

会列出所有在模式中有效的语法，并阐述你为什么可能会希望使用其中的每一个语法。

匹配字面值

可以直接匹配字面值模式。

let x = 1;

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

匹配命名变量

命名变量是可以匹配任何值的不可反驳的模式。

在let语句和match表达式中使用过多次。

不过在match表达式中使用时当出现与外部同名变量时，与普通变量一样，在作用域内会发生覆盖，（要避免这一问题就不要在模式中尤其是Some(T)中定义新变量，还可以参考[match guard部分内容](# 匹配守卫提供的额外条件)）

• match 表达式中作为模式的一部分声明的变量，会覆盖 match 结构之外的同名变量，直到离开match表达式的作用域，外部同名变量才恢复为被覆盖之前的值。

fn main() {
    let x = Some(5);
    let y = 10;  // 外部变量y

    match x {
        Some(50) => println!("Got 50"),
        // 模式引入了一个新变量y,它会匹配任何Some中的值，
        // 同时这个y是在match表示的作用域内定义的，所以当离开此作用域该y就失效了。
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }

    // 这里的y还是开头定义的y=10
    println!("at the end: x = {:?}, y = {:?}", x, y);
}

多个模式

在 match 表达式中，可以使用 | 语法匹配多个模式，它代表 或（or）的意思。

let x = 1;

match x {
    1 | 2 => println!("one or two"),  // 匹配此分支的任一个值就会运行
    3 => println!("three"),
    _ => println!("anything"),
}

通过 ..= 匹配值的范围

..= 语法允许你匹配一个闭区间范围内的值。

• 范围只允许用于数字或 char 值，
  • char 值和数字是 Rust 仅有的可以判断范围是否为空的类型。

// 数字的例子
let x = 5;

match x {
    // 当模式匹配任何在此范围内的值时(1,2,3,4,5)，该分支会执行
    1..=5 => println!("one through five"),
    _ => println!("something else"),
}

// char 值得例子
let x = 'c';

match x {
    'a'..='j' => println!("early ASCII letter"),
    'k'..='z' => println!("late ASCII letter"),
    _ => println!("something else"),
}

解构并分解值

可以使用模式来解构结构体、枚举、元组和引用，以便使用这些值的不同部分。

解构结构体

解构一个结构体时，模式中的变量名不必与结构体中的字段名一致。

• 不过通常使用简写，即变量名与字段名一致时的省略写法。
  • 只列出结构体字段的名称

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

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

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);
或者直接使用简写语法
    let Point { x, y } = p;
    assert_eq!(0, x);
    assert_eq!(7, y);
}

也可以使用字面值作为结构体模式的一部分进行解构。

• 即把部分字段设置为固定的值，解析并匹配部分值确定的情况。

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

    match p {
        // 匹配在x轴上的点
        Point { x, y: 0 } => println!("On the x axis at {}", x),
		// 匹配在y轴上的点
        Point { x: 0, y } => println!("On the y axis at {}", y),
        // 匹配任意点
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }
}

// 上面的p会匹配第二个分支

解构枚举

重要：解构枚举的模式应该与枚举定义中存储数据的方式相对应。

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

fn main() {
    let msg = Message::ChangeColor(0, 160, 255);
    match msg {
        Message::Quit => println!("The Quit variant has no data to destructure."),
        Message::Move { x, y } => {
            println!("Move in the x direction {} and in the y direction {}", x, y)
        }
        Message::Write(text) => println!("Text message: {}", text),
        Message::ChangeColor(r,g,b) => {
            println!("Change the color to red {}, green {}, and blue {}", r,g,b)
        }
    }

解构嵌套的结构体和枚举

enum Color {
   Rgb(i32, i32, i32),
   Hsv(i32, i32, i32),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),  // 嵌套使用了枚举
}

fn main() {
    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));

    match msg {
        // match 需要穷举，所以这里关注的两个也需要全部列举
        Message::ChangeColor(Color::Rgb(r, g, b)) => {
            println!("Change the color to red {}, green {}, and blue {}",r,g,b)
        }
        Message::ChangeColor(Color::Hsv(h, s, v)) => {
            println!("Change the color to hue {}, saturation {}, and value {}",h,s,v)
        }
        _ => ()
    }
}

解构结构体和元组

也可以用复杂的方式来混合、匹配和嵌套解构模式

let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });

忽略模式中的值

使用_忽略整个值

下划线（_）可以作为匹配但不绑定任何值的通配符模式

同时可以在函数参数中使用，当某个参数暂时不需要实现时或不需要关心时。

• 此时编译器就不会警告说存在未使用的函数参数了。

fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {}", y);
}

fn main() {
    foo(3, 4);
}

使用嵌套的_忽略部分值

let mut setting_value = Some(5);
let new_setting_value = Some(10);

match (setting_value, new_setting_value) {
    // 这里不关心具体值是什么，只关心是否有值
    (Some(_), Some(_)) => {
        println!("Can't overwrite an existing customized value");
    }
    // 这里是匹配剩下的情况
    _ => {
        setting_value = new_setting_value;
    }
}

println!("setting is {:?}", setting_value);

let numbers = (2, 4, 8, 16, 32);

match numbers {
    // 这里是忽略部分值
    (first, _, third, _, fifth) => {
        println!("Some numbers: {}, {}, {}", first, third, fifth)
    },
}

通过在名字前以一个下划线开头来忽略未使用的变量

可以用下划线作为变量名的开头，希望告诉 Rust 不要警告未使用的变量。否则创建了变量却没有任何地方使用，Rust 会在编译时给一个警告。

fn main() {
    let _x = 5;
    let y = 10;
}

注意, 只使用 _ 和使用以下划线开头的名称有些微妙的不同：

• 比如 _x 仍会将值绑定到变量，而 _ 则完全不会绑定。
• 以下划线开头的未使用变量仍然会绑定值，它可能会获取值的所有权。
• 只使用下划线本身，并不会绑定值，也不会获取所有权。

let s = Some(String::from("Hello!"));

if let Some(_s) = s {
    println!("found a string");
}

println!("{:?}", s);

用 .. 忽略剩余值

对于有多个部分的值，可以使用 .. 语法来只使用部分并忽略其它值，同时避免不得不每一个忽略值列出下划线。

• 但是要明确，不能有歧义，否则会报错。

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

let origin = Point { x: 0, y: 0, z: 0 };

--正常
match origin {
    // 这里只关心x，忽略y和z，所以可以使用 .. 代替使用两个_
    Point { x, .. } => println!("x is {}", x),
}

--正常
fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        // 这个匹配第一个和最后一个
        (first, .., last) => {
            println!("Some numbers: {}, {}", first, last);
        },
    }
}

--会报错
    match numbers {
        // 会报错，Rust 不知道哪一个是second
        (.., second, ..) => {
            println!("Some numbers: {}", second)
        },
    }

匹配守卫提供的额外条件

匹配守卫（match guard）是一个指定于 match 分支模式之后的额外 if 条件，它也必须被满足才能选择此分支。匹配守卫用于表达比单独的模式所能允许的更为复杂的情况。

let num = Some(4);

match num {
    // 这里除了Some(x)要满足，x<5也要满足
    Some(x) if x < 5 => println!("less than five: {}", x),
    Some(x) => println!("{}", x),
    None => (),
}

使用匹配守卫的情况下，可以在 if 条件中使用外部变量

fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        // 这里新定义了一个变量n，然后用n与外部y相比较
        Some(n) if n == y => println!("Matched, n = {}", n),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("at the end: x = {:?}, y = {}", x, y);
}

也可以在匹配守卫中使用 或 运算符 | 来指定多个模式，同时匹配守卫的条件会作用于所有的模式。

let x = 4;
let y = false;

match x {
    // (4 | 5 | 6) if y => ... 相等
    4 | 5 | 6 if y => println!("yes"),
    _ => println!("no"),
}

// 这里不满足因为y=false，所以会匹配到第二个分支no

@ 绑定

at 运算符（@）允许我们在创建一个存放值的变量的同时测试其值是否匹配模式。

• 语法：新变量 @ 条件
• 使用场景：当我们使用 match 时，匹配的条件是一个范围 1..100,此时如果不绑定一个变量无法在右边语句中使用匹配中的值；看样例。
• 这个语法需要定义一个新变量，（可以与原有字段一样，但是不能省略）

enum Message {
    Hello { id: i32 },
}

let msg = Message::Hello { id: 5 };

match msg {
    // 这里的 id_variable 可以定义为 id,但是因为用来 @符号，所以不能省略
    Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable)
    },
    // 这里没有将字段id绑定到新变量，仅是给id限制一个范围，所以表达式中不能使用id
    Message::Hello { id: 10..=12 } => {
        println!("Found an id in another range")
    },
    // 这里是id:id 的简写，所以可以匹配任何值
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}

这里我们希望测试 Message::Hello 的 id 字段是否位于 3...7 范围内，同时也希望能将其值绑定到 id_variable 变量中以便此分支相关联的代码可以使用它。