basic/match-pattern/match-if-let

[giscus[bot]]

basic/match-pattern/match-if-let

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

[hom]

rust 中使用 match 和 if let 进行模式匹配；match 和 JavaScript 中的 switch case 比较像，match 中的 _ 默认值等同于 switch case 中的 default， match 中的 => 等同于case 关键字后面的 :，另外一点是 match 的模式匹配中不需要添加 break 关键字结束匹配；

[mylvghb]

但是 Javascript 中的 switch case 是就是普通的条件分支语句，不能将 case 块中的值返回给一个变量；而 Rust 中的 match 就能做到这一点。Javascript 中的 switch case 与类 C 的 switch case 一致。不过在最新 .NET 中也引入了”模式匹配“概念， 与 Rust 类似！

[MBearo]

if let Some(3) = v {
println!("three");
}
这里的=不是赋值的意思？

[4innocent]

现在有let else语法了(1.65加入)，更新的是真的快啊😩

[mylyed]

const a = 1;
let b;
if((b = a) == 1){
console.log(b);
} 这个例子形象

[luoyingying123]

    enum MyEnum 
    {
        Variant1(i32),
        Variant2,
    }

    let some_enum = MyEnum::Variant1(3);
    //let MyEnum::Variant1(x) = some_enum;
    if let MyEnum::Variant1(y) = some_enum {}

那为什么注释处的代码会报错？

[luoyingying123]

唔大概懂了，MyEnum::Variant1(3)值可能是None，let语句是不允许这种“可反驳的”(refutable)模式。而if let就当是语法糖吧

[tecwds]

fn main() {
  
    let name = String::from("Tom");

    if let match_name = name {
        println!("match_name = {}", match_name);
    }

    println!("name = {}", name);
}

在vscode当中装了插件，第二个println!就会报错，具体是borrow of moved value: ...，所以也可以看出if let的=是赋值

[keijack]

后面的 变量覆盖，其实就是 Shadowing 吧？

[religou]

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(age) = age {
       println!("匹配出来的age是{}",age);
   }

   println!("在匹配后，age是{:?}",age);
}

在这段程序中，是不是涉及到了变量解构和变量遮蔽（Shadowing）两个知识点，只是单独放在这里是不是不合适？

[chenxiaochun]

哪里涉及到了变量解构？

[religou]

我的理解是在 Some(age) = age 这边, 因为上一条语句 age = Some(30), 所以这边是不是 Some(age) = Some(30)， 那 age 结构成 30 了，纯属个人理解，如果有错误的地方，还请告知，谢谢

[NicholasFirst]

    let x: Option<(String, String)> = Some((String::from("Hello"), String::from("Rust")));
    if let Some((x, y)) = x {
        println!("{} {}", x, y);
    }

这不就解构了..

[XSWClevo]

fn main() {
let age = Some(30);
println!("在匹配前，age是{:?}", age); // 现在的age是Some(30)
if let Some(age) = age {
println!("匹配出来的age是{}", age); // 经过 if let后，age 是i32
}

println!("在匹配后，age是{:?}", age);  // 现在age依旧是Some(30)

}

[chenjingcheng]

if let Some(age) = age {
println!("匹配出来的age是{}",age);
}
age是30 这个没有明白。age怎么覆盖，怎么匹配或赋值的？

[chenxiaochun]

把左边的age改成newAge，这样就能明白了吧

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(newAge) = age {
       println!("匹配出来的age是{}", newAge);
   }

   println!("在匹配后，age是{:?}",age);
}

[i-CNNN]

首先，如下这种写法没意义啊，该if语句恒成立。

let age = Some(18);
if let Some(age) = age {
   println!("这里永远成立");
}

第二行我的理解，此处有两个知识点：

1. 解构，将第一句中Some解构出来；
2. Shadow，将解构出来的18i32赋值重新赋值给了age，当此age脱离if作用域后，该age被回收。如同下面这个例子：

let x = 18;
{
    let x = 20;
    println!("{}",x); // 输出20
}
println!("{}",x); // 输出18

[JK-Wang]

这里用 i32 不太明显，如果是 String 的话其实所有权已经从 age 转移到 Some(age) 中的 age 了

[zhengjiaw]

回复 i-CNNN

这样就不成立了，作者只是举例子让 age 有一个 Some 值，实际情况下，age也有可能是None，所以这种写法是有意义的

fn main() {
    let age: Option<i32> = None;
    if let Some(age) = age {
        println!("这里永远成立");
    } else {
        println!("不成立");
    }
}

[duanyuluo]

确实是shadowing了，原来age是Some（）类型，通过if let或者match后，进行了赋值，age就变成了i32类型了，退出{}，则恢复到Some（）类型。所以，注意看输出。

[ztsweet]

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(x) = age {
       println!("匹配出来的age是{}",x);
   }

   println!("在匹配后，age是{:?}",age);
}

• 非得炫技吗

[ztsweet]

• 我收回我话，小白了

[sryio]

matches! 没有介绍太明白，这种表达式 Some(x) if x > 2 从哪来的就很突兀，参考：
https://mp.weixin.qq.com/s/u1x3-c4M53W-1b6kT_rgOQ

[lemonbiscuits-ljw]

写的非常棒！！

[csx12588]

简单明了

[duanyuluo]

https://docs.rs/matches/latest/src/matches/lib.rs.html#1-161
#[macro_export]
macro_rules! matches {
($expression:expr, $($pattern:tt)+) => {
match $expression {
$($pattern)+ => true,
_ => false
}
}
}
很简单就能理解了，expr是表达式，tt是token，+支持多token，如if x > 2

[allrightsreserved]

fn main() {
let age = Some(30);
println!("在匹配前，age是{:?}",age);
match age {
Some(age) => println!("匹配出来的age是{}",age),
_ => ()
}
println!("在匹配后，age是{:?}",age);
}
由于match开启了一个新的作用域，所以被定义在match表达式内作为模式一部分的变量会覆盖掉match解构外部的同名变量（分支Some(age) 引入了新的变量age，它会匹配Some变体中携带的任意值），正如覆盖其他普通变量一样。

同时通过解构Some(age)=Some(30), 即age=30

[NicholasFirst]

如果使用if let 不解构, 那干嘛不使用 if expression {}

[ghost]

同意

[CodingProgrammer]

这里看到一个关于 if let 语法的讲解，觉得蛮好的，分享给大家：https://www.jianshu.com/p/3004a981750f

[pupudaye]

本章的变量覆盖应该和前面变量章节的变量遮蔽是一个东西

[crownz-sec]

在第一个例子中，Direction::North | Direction::South这么写只是match用"|"来分隔不同情况，实际上，"|"是字节or，"||"还是逻辑or

[ddatsh]

  match dire {
        East => println!("East"),
        Direction::North | Direction::South => {
            println!("South or North");
        },
        _ => println!("West"),
    };

第一个，可以直接是East，后面Direction::North | Direction::South 为什么不能省去Direction:: ？

[bluecode2017]

East 前面不加Direction:: 程序结果是错误的。会直接答应出 East

[ghost]

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(age) = age {
       println!("匹配出来的age是{}",age);
   }

   println!("在匹配后，age是{:?}",age);
}

这里的 if let Some(age) = age ，个人理解左边的age只是一个单纯的临时变量。

基于学习的内容，似乎模式匹配有两种功能：

• 模式匹配：字面意义的模式匹配
• 值的匹配：常见用法

例子当中的用法，似乎属于前者，即字面意义的模式匹配，并非匹配具体的值。因此，age的模式就是 Some(i32)，那么，只要符合这个模式，( ) 中的临时变量叫什么名字都无所谓。这种模式下，只要匹配成功，系统会将age的值赋给这个临时变量（相当于用age的模式来给临时变量赋值，因为=的关系），直到括号结束。

类似地，for循环的变量用法也是：

for v in Vec1 {
    println!("{}", v);
}

v就是临时变量，不管它叫什么名字，都可以进行遍历。

[bluecode2017]

对的。我也这么认为。而且这个临时的age只能在后面的{}里使用

[duanyuluo]

没错👍，所以才要用let

[appdev]

感觉跟 kotlin 的 when 类似

 val url = when (it.type) {
                    1 -> "/my/banned/list/details"
                    2 -> "/my/black/list/details"
                    else -> "/my/violations/help/details"
                }

[ZLD1819858]

Done。
不知道这样理解对不对。（rust小白瞎猜）
let age = Some(30);
let age_i = 30;
if let Some(age) = age_i {
...
//println!("{}", age);
}
这个例子报错信息是：
341 | if let Some(age) = age_i {
| ^^^^^^^^^ ----- this expression has type {integer}
| |
| expected integer, found enum Option
|
= note: expected type {integer}
found enum Option<_>

意思是说，我所要进行匹配的是是age_i，这个是i32类型的，编译器期望“=”左边匹配项应该也是一个{interage类型}，通过这个错误的例子，再多想一想，如果把age_i换成age的话，那就过编译器这一关了，运行的时候在匹配上后，这里还有一次模式匹配，可以理解为这里来了一个新的age变量覆盖了原来的age，作用域在if let表达式中，这个age的类型是i32类型，出了iflet表达式之后，这个新的age出了作用域结束了，再后面使用的age还是Some(30)。

[csx12588]

这里评论区真热闹，是不是到了难点了，整个看下来老费劲了

[ZLD1819858]

这还好.....trait有点小卡

[duanyuluo]

但是，实际上这行代码会报错，因为你无法将 x 直接跟一个枚举成员进行比较。好在，你可以使用 match 来完成，但是会导致代码更为啰嗦，是否有更简洁的方式？答案是使用 matches!：
这里讲的太让人容易引起误解了，就好像enum不能用==，
#[derive(PartialEq, Debug)]
enum MyEnum {
Foo,
Bar
}

fn main() {
let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
let vv: Vec = v.into_iter().filter(|x| *x == MyEnum::Foo).collect();
dbg!(vv);
}
是没有问题的。只不过，第一，enum必须要derive PartialEq trait；第二，用into_iter() -> &MyEnum, 而不是iter() -> &&MyEnum。所以，确实这么写代码会麻烦，所以用match！更方便。

[sbfkcel]

matches! 使用示例代码不完整

v.iter().filter(|x| matches!(x, MyEnum::Foo));
应该为：
let foos: Vec<&MyEnum> = v.iter().filter(|x| matches!(x, MyEnum::Foo)).collect();

[sbfkcel]

又或者是。

let mut v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
v.retain(|x| matches!(x, MyEnum::Foo));

[freesrz93]

基本上就是弱化版的 python match-case，当然，不能跟动态语言比灵活性，而且 python 也没有这种编译器检查。
可以参考 PEP 636

[j4go]

不喜欢if let这种语法糖，很恶心人，不够简明，应该向python学习才是。Mark 23.8.29

[Wan-Yifei]

确实初学的时候感觉是很奇怪的语法，而且VS code一直提示那个let是多余的，但是去掉之后不就是普通if语句了吗？奇怪的设计。

[vc1]

if let 结合这个例子看

#![allow(unused)]
fn main() {
    #[derive(Debug)]
    enum PokerCard {
        Clubs(u8),
        Spades(u8),
        Diamonds(u8),
        Hearts(u8),
    }

    let card = PokerCard::Clubs(123);

    if let PokerCard::Clubs(123) = card {
        println!("1. 精确匹配enum类型和附加数据也相等");
        println!("card变量是{:?}", card);
    }

    if let PokerCard::Clubs(number) = card {
        println!("2. enum类型，附加数据放到变量中");
        println!("card变量是{:?}", card);
        println!("number是{:?}", number);
    }

    if let PokerCard::Clubs(card) = card {
        println!("3. enum类型，附加数据放到同名变量中，被遮蔽");
        println!("card变量是{:?}", card);
        println!("卡片number是{:?}", card);
    }

    println!("card变量是{:?}", card);
}

// 结果
// 1. 精确匹配enum类型和附加数据也相等
// card变量是Clubs(123)
// 2. enum类型，附加数据放到变量中
// card变量是Clubs(123)
// number是123
// 3. enum类型，附加数据放到同名变量中，被遮蔽
// card变量是123
// 卡片number是123
// card变量是Clubs(123)

[vc1]

只匹配enum类型，不关心附带的数据，可以用_

    if let PokerCard::Clubs(_) = card {
        println!("card变量是{:?}", card);
    }

[97Yates05]

请问为什么x 不可以直接跟一个枚举成员进行比较呢，底层是啥原因呢

[saiumr]

在标题 match匹配 部分最后一段

每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值。如果分支有多行代码，那么需要用 {} 包裹，同时最后一行代码需要是一个表达式。

有个疑问，这段最后一句“同时最后一行代码需要是一个表达式”是否正确？因为这段话上面的代码

enum Direction {
    East,
    West,
    North,
    South,
}

fn main() {
    let dire = Direction::South;
    match dire {
        Direction::East => println!("East"),
        Direction::North | Direction::South => {
            println!("South or North");
        },
        _ => println!("West"),
    };
}

这里的println!("South or North");是一个语句吧？

[mumumusuc]

println!返回()，{...}也返回()，所以match的返回值是()；如果是_ => let _ = 0,这样的分支，编译器就会告诉你需要一个表达式而不是语句

[jareguo]

ChangeColorRGB(u16, u16, u16) 形参定义成 ChangeColorRGB(u8, u8, u8) 更准确点

[iGwkang]

调试的时候发现match匹配按顺序匹配，如果_在前面，match会匹配到_，只要是_开头的任意值都能匹配到，例如_abcd也会被match匹配到

[mdmjmsa]

不少东西给出的太突兀，没有等价的解释说明。if let <pattern> = var {} 语法简直是奇葩，if 其实是判断匹配是否成功，<pattern> 是匹配模式，可支持模式绑定，把匹配到的值“抽取”到一个局部变量。但是这里用 let 就很奇葩，还不如设计一个专门的匹配操作符, 例如 if <patter> ~= var {}。

[toplyb]

不太明白 let v = Some(3u8); 中 3u8 是什么意思？

[luoyingying123]

类型为u8的3

[171h]

总感觉 if let 好奇葩，我就想知道下面两种写法有啥区别？

if let Some(3) = v {
    println!("three");
}

if Some(3) == v {
    println!("three");
}

[Wan-Yifei]

我查了下英文的资料，在你的两个例子中他们是没区别的，但是底层的操作不一样。==关注的是数值是否相等，而if let 关注模式或者数据模式是否相同, 是把Some(3) 作为一个enum枚举类型在比较类型。
而且if let 同时有赋值功能，如果是Some(i) = v, v的值会被赋予i形成一个在此处可用的临时变量。
另外最重要的是 == 只支持有PartialEq的对象，而if let 没有这个限制。

[zcjie1]

我感觉if和if let的区别是：

1. if只实现了（类型和值的判断）
2. if let实现了（类型的判断）+（值的判断 || 赋值）

你给出的情况中，Some(3)中的3是一个值，所以if let会进行（类型的判断）+（值的判断），你把3改成4，就匹配不上了；
如果把Some(3)中的3换成一个变量的名字，if let就会进行（类型的判断）+（赋值）

[Wan-Yifei]

关于变量遮蔽，官方英文书上的例子更好理解：

fn main() {
    // All have type `Option<i32>`
    let number = Some(7);

    // The `if let` construct reads: "if `let` destructures `number` into
    // `Some(i)`, evaluate the block (`{}`).
    if let Some(i) = number {
        println!("Matched {:?}!", i);
    }
}

变量number 如果复合Some(i)的模式，number就会被赋值给临时变量i。这个例子两个变量名字不同，就很好理解是谁赋值给谁。如果此时把临时变量名字从i改成number那么在这个段落中原本的number就会被新创建的临时变量number覆盖。
不过理解这个之后我感觉if let语句其实只是对于传统if else条件语句的强化，而不是模式匹配的强化。

[syejing]

#[derive(Debug, PartialEq)]
enum MyEnum {
Foo,
Bar
}

fn main() {
let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
let ret: Vec<_> = v.iter().filter(|x| {
if let MyEnum::Foo = x {
true
} else {
false
}
}).collect();
println!("{:?}", ret);
}

[trytew]

let thread: thread::JoinHandle<()> = thread::spawn(move || loop {
    let msg: Result<Job, mpsc::RecvError> =
        receiver.lock().unwrap().recv();

    match msg {
        Ok(job) => {
            println!("Worker {id} got a job; executing.");
            job();
        }
        Err(_) => {
            println!("Worker {id} disconnected; shutting down.");
            break;
        }
    }
});

let response: Frame = match Command::from_frame(frame).unwrap() {
    Set(cmd) => {
        db.insert(cmd.key().to_string(), cmd.value().to_vec());
        Frame::Simple("OK".to_string())
    }
    Get(cmd) => {
        if let Some(value) = db.get(cmd.key()) {
            Frame::Bulk(value.clone().into())
        } else {
            Frame::Null
        }
    }
    cmd => panic!("unimplemented {:?}", cmd),
};

在上述的两个例子代码中，match的分支到底是看作代码块还是函数？如果是看作函数但是它可以直接break中断循环，如果是看作代码块但是它又像函数一样返回值到变量，而且很难受的是match里面的返回不能用return