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]

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

[aaurix]

反复看了几遍

[XHXHXHX]

[artillerymans]

自己写一下 你会发现的

[ZLD1819858]

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

[madaono]

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

[crypto-le]

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

可辨驳的（对于某些可能的值，无法进行匹配的模式）例如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，就模式匹配而言，匹配成功

[hnt3721]

变量是一种模式

[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 覆盖的结果？

[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);
}
}

[baiseng]

.pop()又给套了一层options。用vscode编辑器认真观察只能提示类型就能分析出来。

[j4go]

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

[zard999]

done

[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"
}

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

[baiseng]

大佬辛苦了，我认真看完了。非常棒，通透

[maolovecoding]

佬 太强了。 看完了 好像真懂了 辛苦 我只能赞一下了 哈哈

[yanghao5]

for 循环那可以加上，下面这个

let a = [10, 20, 30, 40, 50];

for &i in a.iter() {
    // i 是 i32 类型
    println!("值为 : {}", i);
}

for i in a.iter() {
    // i 是 &i32 类型
    println!("值为 : {}", i);
}

这也就解释了 &item 是什么东西
https://course.rs/basic/trait/generic.html#泛型详解

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

或者把这些内容加到 https://course.rs/advance/smart-pointer/deref.html 中

[JavaZeroo]

let 和 if let 解决了两节都看不懂的问题😂

[xryptoc]

if let是不是还有一种更好记忆的方式， (其实人家已经匹配了所有情况了，只是其余情况都在else里呢，哈哈(✿◡‿◡))

[guoqi-z]

请教一下在函数
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({}, {})", x, y);
}
中, 为什么形参是使用&(x, y)而不是使用(x, y)呢

[mayathomas]

&是传递的引用，而直接(x,y)则传递的是所有权，在rust中，函数传参尽量在必要的时候才使用所有权，一般都用借用即可，否则别人调用你的函数会导致他的数据没法再次使用。或者你的函数必须要用所有权，可以把处理后的数据再返回给调用者。

[w3hh3w]

Vec 类型的 pop 方法返回一个 Option

[w3hh3w]

Ok 是 Rust 中 Result 枚举的一部分。Result 枚举用于表示操作的结果，它可以是成功（Ok）或失败（Err）

[Azleal]

let else匹配中，为什么说后面的代码块一定需要发散代码块处理？

[nzj1981]

//当while let遇到嵌套Options时
let my_arr = [Some(1), Some(2), Some(3), Some(4), None, Some(5)];
let mut my_vec = Vec::from(my_arr);
//while let Some(top) = my_vec.pop().unwrap() { //加上unwrap()解构嵌套Options
// println!("my_vec pop: {top:?} ");
//}
//另一种方法
// while let Some(top) = my_vec.pop() {
// let Some(_) = top else {break;};

// }
//再另一种方法
//while let Some(Some(top)) = my_vec.pop(){
// println!("my_vec pop:{top:?}");
//}
//再再另一种方法
//while let Some(top) = my_vec.pop(){
// match top {
// Some(tp) => println!("my_vec pop:{tp:?}"),
// None => break,
// }
//}
//再再再另一种方法
while let Some(top) = my_vec.pop(){
if let Some(tp) = top {
println!("my_vec pop:{}", tp);
} else {
break;
}
}
println!("Curr my_vec value: {my_vec:?}");

[happyfeetw]

求这一部分的练习题 :)

[qmlCoder]

好难啊好难

[fuochai]

let else解决了没法在unwrap_or_else()里使用break return之类的痛点

[sage417]

let (a, b): (bool,bool) = (true, false);
用这个例子更能体现let语句也用到了模式匹配

[jim-yefeng]

有关绑定，我的理解
如果是新变量，则可以绑定到任何值；如果是旧变量，新值需要和旧值一致才能绑定成功，才能作为条件判断中的 true 状态

[TangChen160186]

其实这样理解就好了：
let PATTERN [: TYPE] = EXPRESSION;
它其实执行了三个步骤
1.计算右侧表达式。
2.类型检查，如果没有指定类型，就绝对检查通过的
3.执行模式匹配，也就是那个变量名字，比如let (a, b) = (1, 2); 就会和(a,b)这种模式匹配，规则就是表达式值结构之后个数相同。