Rust编程-模式匹配

模式：

        用来匹配类型结构

        组成：字面量、解体的数组、元组、枚举、结构体 、变量、通配符、占位符等组件组成

模式匹配的作用：

        模式与match或其他工具配合使用可以更好控制流程

match分支：

        

match 值 {
    模式 => 表达式
}

        match分支要求必须穷尽匹配值的所有可能性

        可以在最后一个分支上使用全匹配模式：

                使用一个可以匹配任何值的变量名

                使用_模式

if let条件表达式：

        可以混用if let 、else if、else if let 、else

        不会要求开发者穷尽所有可能性

 where let 循环：

        循环匹配

  for循环：

        for语句中紧跟for关键字的就是一个模式

let语句：

        

let PATTERN = EXPRESSION;

let (x, y, z) = (1, 2, 3); // let 结构元组

如果模式中的元素数量和表达式中的不同，会引发错误

可以使用使用_或..语法忽略元组中的元素，_只能匹配一个，.. 可以匹配多个

 函数的参数：

        函数的参数也是模式

        可以在函数参数中使用模式去匹配元组

        

fn print_coordinates(&(x, y): &(i32, i32)) {}

        可以在闭包的参数列表中使用模式

 模式在不同上下文中的运作机制

        模式可以被分为不可失败（irrefutable）和可失败（refutable）两种类型。

        不可失败性：let x = 5;

                函数参数、let语句及for循环只接收不可失败模式

        可失败性：let Some(x) = a_value

                if let和whilelet表达式则只接收可失败模式

        注意：编写代码时不需要考虑模式的可失败性，但需要知道概念，在异常信息中能够识别。

    模式语法：            

                匹配字面量：

                        

match 1 {
        1 => println!("one"),
        2 => println!("two"),
        _ => println!("other"),
    }

                匹配变量：

let x = Some(50);

match x {
 ...
}

match表达式创建的新作用域:

        

 let x = Some(5);
    let y = 10;
    match x {
        Some(50) => println!("50"),
        Some(y) => println!("Matched,y={:?}", y),
        _ => println!("other"),
    }

会匹配到第二个分支，这里的y在match创建的作用域内，是一个新的变量，不是x后面的y变量

        多重模式

                使用“|” 来实现多重模式匹配

        

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

         ..= 来匹配值区间

            ..= 是为了解决 | 一次只能添加一个值的复杂性；

            使用“. .= '表示包含范围，包含起止

             范围模式只允许数字和char类型的数值使用

结构分解值：

            模式来分解结构体、枚举、元组或引用

             解构结构体：

let p = Point { x: 0, y: 7 };
    match p {
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        Point { x: 0, y } => println!("On the y axis at {}", y),
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }

           结构枚举：

                

 let msg = Message::ChangeColor(1, 2, 3);
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move {},{}", x, y),
        Message::Write(text) => print!("write {}", text),
        Message::ChangeColor(r, g, b) => {
            println!("change the color to red {},green {},and blue {}", r, g, b)
        }
    }

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

        嵌套枚举

                

let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => println!("Rgb,{},{},{}", r, g, b),
        Message::ChangeColor(Color::Hsv(h, s, v)) => print!("Hsv,{},{},{}", h, s, v),
        _ => (),
    }

        嵌套结构体和元组

        

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

        使用_忽略：

        

let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, _, third, _, fifth) => {
println!("Some numbers: {}, {}, {}", first, third, fifth)
},
}

  _ 不一定非要放到最后

.. 两个点，可以省略多个值，也一定要放到最后

        匹配守卫

        match分支模式后的if条件语句

        

let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(n) if n == y => println!("Matched, n = {:?}", n),
_ => println!("Default case, x = {:?}", x),
}

条件中的y就是来自表达式外部的y, 匹配守卫if n == y不是一个模式，所以它不会引入新的变量.能够比较n和y的值是否相同。

        @绑定

        @运算符允许在测试一个值是否匹配模式的同时创建存储该值的变量。

   enum Message {
        Hello { id: i32 },
    }
    let msg = Message::Hello { id: 5 };
    match msg {
        Message::Hello {
            id: id_variable @ 3..=7,
        } => {
            println!("Found an id in range: {}", id_variable)
        }
        Message::Hello { id: 10..=12 } => {
            println!("Found an id in another range")
        }
        Message::Hello { id } => {
            println!("Found some other id: {}", id)
        }
    }