basic/match-pattern/pattern-match

[giscus[bot]]

basic/match-pattern/pattern-match

https://course.rs/basic/match-pattern/pattern-match.html

[ohmycloud]

模式匹配有可驳模式和不可驳模式两种。
if let 和 while let 就属于可驳模式匹配。

[sunface]

是的，我准备在其中做一下简单注释，感谢提示

[nasuf]

if let模式匹配是不是可以理解成，判断左右两侧类型匹配成功与否？匹配成功则正确赋值给左侧变量，否则匹配失败

[zhangdekui]

匹配成功时看左边表达式有没有变量, 有就解构.

[fenglea]

赋值跟解构的区别是什么呢

[mayathomas]

解构属于赋值，是一种特殊的赋值

[ZLD1819858]

解构即：已知原有的结构，解开该结构；
举例：对于一个元组来，你知道这个元组的元素类型和元素个数，即知道这个结构是怎么样的，那你需要解开一个结构（解构）一个对象（实例）的目的是什么呢？（获取对象的数据）。而赋值呢，和解构的意思就不一样了，更像是你人为的给一个变量赋予一个有意义的值，而这个值的结构由你来定，例如将一个数组绑定到一个变量上。

emmm这样理解应该没毛病吧

[csx12588]

if let PATTERN = SOME_VALUE { } 后面左右两侧的值都是已知的吧，左右两侧匹配则执行{ } 的指令

[yueqianzhang]

新知识 get，原来处处都是模式匹配

[okzkx]

把模式（pattern）看作正则表达式就好理解多了

[GmwEnterprise]

感觉好奇怪啊这个东西。。。

[0xdigiscore]

反复看了几遍

[XHXHXHX]

[artillerymans]

自己写一下 你会发现的

[ZLD1819858]

或许可以理解为模板，你要用一个模式（模板）来解构某个变量。

[madaono]

感觉非常像ts的解构赋值啊

[790228724]

可辩驳性：模式是否会无法匹配§
模式的两种形式：

可辨驳的（对于某些可能的值，无法进行匹配的模式）例如if let Some(x) = a_value，当右边是None是就无法匹配
不可辩驳的（能匹配任何可能传递的值的模式，不可能失败的，怎么都会成功）例如let x = 5;
函数参数、let语句、for循环只接受不可辩驳的模式。而if let和while let接受可辨驳和不可辩驳的模式。例：

[cddsgtc]

匹配模式是rust的一种语法。

[framist]

感觉模式匹配的思想与 Coq 中“构造子”的思想很像

[Autumnin2000]

没太明白
为什么说 let x = 5 是一种模式匹配，我理解既然是匹配这个词，从字面意义上来说就应该是A和B两者之间的关系才对，但我凭空写一个 let x = 5，在这里谁是A，谁是B？

[liuhq]

let x: i32 = 5
其中，x 和 5 的类型相同，都是 i32，就模式匹配而言，匹配成功

[findre]

let my_vec = [Some(1), Some(2), Some(3), Some(4), None, Some(6)];
let mut case5 = Vec::from(my_vec);
while let Some(tp) = case5.pop() {
    println!("case success {:?}", tp);
}

为什么这段代码会产生：
case success Some(6)
case success None
case success Some(4)
case success Some(3)
case success Some(2)
case success Some(1)

这样的结果，难道不应该是在-2 索引时候退出 while 吗 Some(None) 是 while let 覆盖的结果？

[qing-peng]

my_vec的类型是[Option], .pop()返回的类型就应该是Option<Option>

[AlreadyM]

多谢多谢，理解更加深刻。没有什么是多加一层解决不了的，如果有就再加一层 -…-

[duanyuluo]

注意，你的原意应该是输出case success 5把？但是pop返回的是Some（5）。如果:
fn main() {
let mut my_vec = vec![Some(1), Some(2), Some(3), Some(4), None, Some(6)];
//let mut case5 = Vec::from(my_vec);
while let Some(tp) = my_vec.pop().unwrap() {
println!("case success {:?}", tp);
}
}
才会如你预期，只会有一行输出，然后就终止了。

[uyplayer]

fn main() {
    let my_vec = [Some(1), Some(2), Some(3), Some(4), None, Some(6)];
    let mut case5 = Vec::from(my_vec);
    while let Some(option_tp) = case5.pop() {
        if let Some(tp) = option_tp {
            println!("case success {:?}", tp);
        }
    }
}

[Z-JaDe]

fn main() {
let my_vec = [Some(1), Some(2), Some(3), Some(4), None, Some(6)];
let mut case5 = Vec::from(my_vec);
while let Some(Some(tp)) = case5.pop() {
println!("case success {:?}", tp);
}
}

[j4go]

人是不是越来越少了，评论少了不少

[zard999]

done

[Innovationlzc]

我题呢

[ChinaRedArmy1930]

这一大章还是没太懂

[Eden-cola]

之前在语句和表达式中有提到 let 未来可能会成为一种表达式，如果 let 真的成为了一种表达式，那么 if let 这种写法：

if let Some(x) = some_option_value {
  println!("{}", x);
}

就会给人一种 let Some(x) = some_option_value 是一个返回 bool 的表达式的感觉，但实际上并不是，因为这一句单独拿出来用会报错……方便是方便，但总感觉哪里怪怪的，这个语法给我一种不那么自洽的感觉。
在这个场景下，let 不是表达式感觉反而好一点。

[liuhq]

你漏看了可驳和不可驳俩模式。
之所以 let Some(x) = some_option_value 会出错，是因为 let 是不可驳匹配模式，需要覆盖所有可能出现的情况，即 Option 枚举类会有 Some(x) 和 None 两种情况；let Some(x) = some_option_value 你只覆盖了 Some(x) 这种，自然报错。
而 if let 是可驳匹配模式，只需要覆盖其中一种情况即可，所以可以这样写。

[q13945951476]

// Vec是动态数组
let mut stack = Vec::new();

// 向数组尾部插入元素
stack.push(1);
stack.push(2);
stack.push(3);

// stack.pop从数组尾部弹出元素
while let Some(top) = stack.pop() {
println!("{}", top);
}

while 这没理解，stack.pop()返回的是符合Some（top）的？还是说，所有的值都是option？

[GangJust]

为了避免越界或者null情况，Rust对于 Vec 的pop操作返回的是一个 Option 呀。

// Vec::pop() 内部函数结构。
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn pop(&mut self) -> Option<T> {
    // ...
}

[Wan-Yifei]

Rust果然有自己独立一套方法论，把赋值认为是一种模式匹配。对于 let x: i32 = 5, 变量名x是一种类似通配符的模式，只要数据类型相同就能配上。有留言说把模式理解成某种正则我认为是个有启发性的类比。但是目前我还看不出来Rust采用万物归于匹配的设计其优点何在？等待高人。

[YiiMus]

在函数参数一节中

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("Current location: ({}, {})", x, y);
}

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

这其中我在自己的ide中试了一下发现fn print_coordinates(&(x, y): &(i32, i32)) 也可以写成 fn print_coordinates((x, y): &(i32, i32))。这两种都是可以的，第一种写法 &(x, y) 更明确地指出参数是一个引用，而第二种写法 (x, y) 依赖于 Rust 的类型推断来达到相同的目的。

[kbpoyo]

在这里写下一些自己的理解。

重看 let 语句

我将rust 中的赋值操作看作两个步骤，分别是模式匹配和变量绑定，将 let 语句中的变量看作通配符，可用来匹配并绑定该变量类型对应的所有值。

let x: i32 = 1i32;

如上面语句中的x变量，其类型为i32，所以x可以匹配i32类型下的所有值，可先将“ = ”左边看做一个集合，集合中的值为i32可表示的所有值（-2³¹~2³¹ - 1），而“ = ”右边为i32类型的一个值“1”。

步骤一：模式匹配
我将模式匹配看作一个包含关系的判断，即“ = ”右边的值是否包含在“ = ”左边的集合中，若包含，则匹配成功，若不包含则匹配失败。但是匹配的条件为” = “左边值的集合必须包含该类型的所有值，否则应使用if let或者let else语句进行绑定，以便在匹配失败时进行相应处理。

步骤二：变量绑定
当匹配成功后，使用“ = “左边的模式串对“ = ”右边的值进行解构，完成变量与值的绑定。上面代码中，模式串为’x‘, x可匹配i32的所有值，所以将值1绑定到变量x上。

几个模式匹配的例子

enum Opt {
    AAA,
    BBB(u32),
    CCC(i32, u32),
    DDD { x: i32, y: u32 },
}

fn main() {

    // "=" 左边是值的集合，右边是值的个例
    let a: Opt = Opt::AAA;       // 集合包括所有个例，可以匹配成功并进行变量绑定
    let b: Opt = Opt::BBB(1);    // 同上
    let c: Opt = Opt::CCC(1, 2); // 同上
    let d: Opt = Opt::DDD { x: 1, y: 2 }; // 同上
}

上面4条绑定语句中，因为变量类型都为Opt, 即各变量都可匹配Opt类型的所有值，所以” = “左边可看作类型为Opt的所有值的集合，而” = “右边的值都包含在集合中，所以都可以匹配成功，并将变量与值绑定。

 // 集合只包括 Opt::BBB(u32)的所有值，而"="右边的个例类型为Opt, 即左边的集合中没有包括完右边个例的类型所应该包含的所有值，所有无法进行匹配
  let Opt::BBB(x) = b; //error 

上面的绑定语句中，” = “左边的值的集合为Opt::BBB(u32) ，但该值的类型Opt所包含的值还包括Opt::AAA, Opt::CCC(i32, u32), Opt::DDD{x: i32, y: u32} 所以不满足匹配条件，无法进行模式匹配。

  // 使用if let进行匹配, 忽略集合中没有的值，可进行匹配，并在成功后进行变量绑定
    if let Opt::AAA = a {
        println!("ok");
    }

	if let Opt::BBB(x) = b {//x通配u32
        println!("x = {}", x); //x = 1
    }
    
    if let Opt::CCC(x, y) = c {//x通配i32, y通配u32
        println!("x = {}, y = {}", x, y); //x = 1, y = 2
    }

    if let Opt::DDD { x: n_x, y: n_y } = d {//x通配i32, y通配u32
        println!("new_x = {}, new_y = {}", n_x, n_y); //n_x = 1, n_y = 2
    }

当” = “左边值的集合是其类型所有值的集合的子集时，可以使用if let或者let else语句来忽略集合中缺少的部分值，以使在匹配失败时进行相应处理。模式串Opt::AAA没有变量作为通配符，所以在匹配成功后不进行变量绑定，模式串Opt::BBB(x) 中，变量x作为通配符匹配所有u32类型的值，可在匹配成功后，对b的值Opt::BBB(1) 进行解构，并将解构得到的值1绑定到变量x。

其它例子

在完成rust的变量赋值和模式匹配的理解后，随意编写了几个模式匹配的例子，发现都能通过编译。

let x = 'a';
if let 'a'..='z' | 'A'..='Z' = x {
    println!("ok");
}

let x = String::from("hello");
if let "hello" | "world" = x.as_str() {
    println!("ok");
}

// if let String::from("hello") | String::from("world") = x {   // 模式串中不能进行函数调用
//     print!("ok");
// }

let x: [i32; 4] = [1, 2, 3, 4];
if let [1, 2, __, 4] | [5, 6, 7, 8] = x {
    println!("ok");
}

if let [1, new_x, 3, 4] | [5, new_x, 7, 8] = x {
    println!("new_x = {}", new_x); //new_x = 2
}

if let &[1, 2, 3, 4] | &[2, 3, 4, 5] = &x {
    println!("ok");
}

if let 1..=10 | 5..=15 = 10i32 {
    println!("ok");
}

if let (x, 1..=10) = (1, 2) {
    println!("x = {}", x); // x = 1
}
if let (x, &[2, 4] | &[0, 1]) = (String::from("value"), &[2, 4]) {
    println!("x = {:?}", x);// x = "value"
}

由上也可看出符号” __ "其实和变量类似，但只起到了通配符的作用，在匹配成功不进行变量绑定。