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 中“构造子”的思想很像

[born-in-autumn]

没太明白
为什么说 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

[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)这种模式匹配，规则就是表达式值结构之后个数相同。

[3517277]

1.88的版本增加了更方便的方法：
if let Channel::Stable(v) = release_info()
&& let Semver { major, minor, .. } = v
&& major == 1
&& minor == 88
{
println!("let_chains was stabilized in this version");
}

[duckerbaichi]

let-else(Rust 1.65 新增)
使用 let-else 匹配，即可使 let 变为可驳模式。它可以使用 else 分支来处理模式不匹配的情况，但是 else 分支中必须用发散的代码块处理（例如：break、return、panic）。请看下面的代码：

use std::str::FromStr;

fn get_count_item(s: &str) -> (u64, &str) {
let mut it = s.split(' ');
let (Some(count_str), Some(item)) = (it.next(), it.next()) else {
panic!("Can't segment count item pair: '{s}'");
};
let Ok(count) = u64::from_str(count_str) else {
panic!("Can't parse integer: '{count_str}'");
};
// error: else clause of let...else does not diverge
// let Ok(count) = u64::from_str(count_str) else { 0 };
(count, item)
}

fn main() {
assert_eq!(get_count_item("3 chairs"), (3, "chairs"));
}
与 match 和 if let 相比，let-else 的一个显著特点在于其解包成功时所创建的变量具有更广的作用域。在 let-else 语句中，成功匹配后的变量不再仅限于特定分支内使用：

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

// let-else
let Some(x) = some_option_value else { return; }
println!("{}", x);
在上面的例子中，if let 写法里的 x 只能在 if 分支内使用，而 let-else 写法里的 x 则可以在 let 之外使用。

最后这段儿东西 我觉得, 讲的是乱七八糟 术语横飞
无端浪费别人时间 简直是谋财害命
就俩例子一说就完事儿了 扯那么一大段

例子1

let x = match x {
    Some(x) => x,
    _ => return, // 或 panic!(), break 等
};

例子2 使用语法糖
let Some(x) = x else { //x是Option, 如果x是Some 代表类型匹上了, 给Some值掏出来 赋值给x变量, 这个x变量没有体限制, 外部可用
return;
};

[ChengYan-3721]

每次回来看都能学到新知识