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 类似！

[qiuyefeihong]

match跟Javascript中
const fun = {
case1: () => {
return 1
},
case2: () => {
return 2
}
}
let fun_case = "case1"
let result = fun[fun_case] ? funfun_case : "";
这种写法有点类似呀

[qiuyefeihong]

最后一句应该是 let result = fun[fun_case] ? fun[fun_case] : "";
写的有点小问题！

[MBearo]

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

[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的=是赋值

[cloudscola]

String类型没有实现copy的特征，在 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有点小卡

[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匹配到

[xbsheng]

不是 _ 开头的也能匹配到，把 _abcd 改为 abcd 是一样的效果

[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

[YiiMus]

假设有一个枚举类型

enum Num{
      Val(i32)
}

那么在match中使用模式匹配的模式绑定

let num = Num::Val(100);
match num {
     Num::Val(x) => println!("{}",x)
}

请问这里的Num::Val(x)是否是枚举类型的解构呢？
那 let Num::Val(msg) = num; 这个语句呢？

[YiiMus]

好吧，后面我搞明白了。无论是Num::Val(x)还是let Num::Val(msg) = num;，它们其实都是rust的模式绑定，模式绑定不仅仅用于枚举，还能用于结构体，元组等等

[YiiMus]

哈啊哈，例如这样

    struct Apple {
        color: String,
    }

    // 创建一个 Apple 实例
    let my_apple = Apple {
        color: String::from("Red"),
    };

    // 使用模式匹配语句解构 Apple 实例
    let Apple { color: x } = my_apple;

    // 现在可以直接使用 x 变量
    println!("The color of the apple is {}", x);

[radish999]

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

fn main() {
let v = vec![MyEnum::Foo, MyEnum::Bar, MyEnum::Foo];

let v2: Vec<MyEnum> = v.into_iter().filter(|x| matches!(x, MyEnum::Foo)).collect();
println!("{:?}", v2);

}

[woshisbb43]

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

我为什么不直接写
if Some(3) == v {
println!("three");
}

[GavZheng]

在Rust 1.80.0中，模式可以使用独占端点，写为a..b或..b，类似于Range和RangeTo表达式类型，望作者大大更新。同时要感谢作者大大和本书编纂者们对Rust社区作出的非凡贡献，使我们收获了一本优秀的Rust入门书，Thanks

[boxstudy]

fn main() {
    let num = 50;

    match num {
        0 => {}
        1 | 2=> {}
        10..=20 => {}
        30..=40 | 50 => {}
        60..=70 | 75..=80 => {}
        x if num < 0 && num%2 == 1 => {}
        _ => {}
    }
}

[guoqi-z]

请教一下, matches宏的例子中, assert!(matches!(bar, Some(x) if x > 2)); 这句代码中的matches!(bar, Some(x) if x > 2)怎么理解啊

[hzgnjupt]

参见 2.6.4 的 “匹配守卫提供的额外条件” 这一节。
匹配守卫（match guard）是一个位于 match 分支模式之后的额外 if 条件，它能为分支模式提供更进一步的匹配条件。
assert!(matches!(bar, Some(x) if x > 2)); 表示只有在 bar 为 Some 且 x 满足 x > 2 的条件时，匹配才会成功。