basic/match-pattern/all-patterns

[sunface]

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

[acfuns]

下文展示了固定某个字段的匹配方式：


fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        Point { x: 0, y } => println!("On the y axis at {}", y),
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }
}
首先是 match 第一个分支，指定匹配 y 为 0 的 Point； 然后第二个分支在第一个分支之后，匹配 y 不为 0，x 为 0 的 Point; 最后一个分支匹配 x 不为 0，y 也不为 0 的 Point。

这里表达错误了，第二个分支指定匹配 x 为 0 的 Point，而不是匹配y不为0，x为0的Point，可以匹配y为0的Point，建议更改一下。

[mxismean]

其实表述可以再精确一点

[mxismean]

首先是 match 第一个分支，指定匹配 y 为 0 的 Point； 然后第二个分支在第一个分支之后，x 为 0 的 Point; 最后一个分支匹配 x和y 为任意值的 Point。从上往下依次进行匹配。匹配到一条分之后就不会再往下进行匹配了。

[jinliming2]

可是 y 为 0 的情况在第一个分支就已经匹配到了。所以 y 为 0 的情况不会进入第二个分支。
所以说第二个分支字面上可以匹配 y 为 0 的情况，但实际情况是不会匹配。

[madaoCN]

y == 0 不会进入到第二个分支

[ZLD1819858]

可以理解为：第一关boss打过了，才能打第二关。
match下模式匹配是串行的而不是并行的，前面的都匹配失败了才会匹配后面的。

[sunface]

下文展示了固定某个字段的匹配方式：


fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        Point { x: 0, y } => println!("On the y axis at {}", y),
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }
}
首先是 match 第一个分支，指定匹配 y 为 0 的 Point； 然后第二个分支在第一个分支之后，匹配 y 不为 0，x 为 0 的 Point; 最后一个分支匹配 x 不为 0，y 也不为 0 的 Point。

这里表达错误了，第二个分支指定匹配 x 为 0 的 Point，而不是匹配y不为0，x为0的Point，可以匹配y为0的Point，建议更改一下。

x=0,y=0 会匹配第一个分支，匹配不到第二个

[doge-ak]

也就是说和语法没有关系，就是个逻辑问题

[ZLD1819858]

或许加上一句：match模式匹配是串行的而不是并行的？这样更好理解一点。

[DylanJinx]

“x=0,y=0 会匹配第一个分支，匹配不到第二个”这段话应该改一下，是：“x=0,y=0 会匹配第一个分支，匹配不到第三个”
同理： let p = Point { x: 0, y: 7 }; 会被第二个分支匹配到，虽然也可以被第三个分支匹配到，但是被第二个分支抢先了，match已经返回值并结束了生命周期。

[ohmycloud]

@绑定可能是所有模式匹配中最难记忆的一个。

let p @ Point {x: px, y: py } = Point {x: 10, y: 23};

我现在这样助记： @ 符号右侧的 Point {x: px, y: py } 是一个模式(pattern), 如果这个模式匹配就把匹配值绑定到 @ 符号左侧的 p 变量上。

[Jesse-666]

好办法 加深记忆

[sinopec]

这要是结合所有权转移，那就酸爽了....

[duanyuluo]

TDMaker精辟哈

[JoshuaGhost]

抖个机灵：与其说想用 = 的地方没地方用，不如说想用 : 的地方没地方用吧
let p:Point {x: px, y: py } = Point {x: 10, y: 23};
就是
let var:pattern = right_value
多顺耳

[sxfreesky123]

标题就已经帮你想好怎么记了. @前绑定后解构. 就是@左侧做变量绑定， 右侧做解构. 解构的前提肯定是模式匹配.

[jimbaMe]

fn main() {
    let x = Some(String::from("a"));
    let y = false;
    match x {
        Some(s) if y => println!("{}",s),
        Some(s) => println!("{}",s),
        _ => println!("jjj"),
    }
    println!("{:?}",x);
}

能问一下吗，在match中第一个分支中x匹配了some（s）此时x的所有权转移到了s中了吗？如果转移到了s上那么因为匹配守卫的关系，这一分支就不匹配了，这时应该匹配第二还是第三个分支。

[anson0370]

感觉直接这么解释不太对。

对于 s.len() 调用来说确实没有发生 move ，这所谓的没发生 move 是 s 没有向 len() 方法内发生 move 。但 s 本身也是一个新的变量，从 Some(s) 的匹配上来看，s 的类型应该是 String ，那么在调用 s.len() 的时候，实际上这个 s 必然是把 x 中的 String move 过来才能使用（否则哪来的呢？）。
感觉这里有点 trick ，我只能理解为在 match guard 执行期间临时发生了 move 但因为最终没匹配上所以把 move fallback 了？

[ZLD1819858]

楼上哥们讲的很有道理，打个比方：首先你要交钱买门票去打Boss（s拿到所有权，Some(s)模式匹配通过了），但是Boss关门口有个守卫（匹配守卫），它专门来检查你战力够不够打Boss的，发现不够把你劝退了不让进去打还把门票钱退给你（匹配守卫条件false，撤销s的所有权，还给x），如果战力够那么你进去打，门票钱肯定就不退给你了（匹配守卫条件true，确定所有权归s了）。

[Nixicodo]

5楼的ZLD1819858老哥的比喻生动形象。

[xisaixi]

但是5楼的解释，像是所有权借用了，就不是move了呢
是不是x的所有权是move到match这整个模式匹配里面去，所以第一条匹配不上，跳到第二条匹配这期间不会有所有权的转移。。
然后最后这行println!("{:?}",x);是会报错的，说明所有权是move到了match里面没有出来
fn main() {
let x:Option<&str> = Some("a");
let y:bool = false;
match x {
Some(s:&str) if y => println!("{}",s),
Some(s:&str) => println!("{}",s),
_ => println!("jjj"),
}
println!("{:?}",x);
}
这样用引用就是ok的呢

[baober90]

@xisaixi 你这个demo用的是&str类型,即字符串切片引用类型,是具有Copy特征的,不涉及所有权问题.

[zhangdekui]

    let p @ Point { x: px, y: py } = Point { x: 10, y: 23 };
    println!("x: {}, y: {}", px, py);
    println!("{:?}", p);

是不支持吗????

error[E0658]: pattern bindings after an @ are unstable
--> src/main.rs:183:24
|
183 | let p @ Point { x: px, y: py } = Point { x: 10, y: 23 };
| ^^
|
= note: see issue #65490 rust-lang/rust#65490 for more information

[Rustln]

首先是支持的，您可能需要确认一下您 Rust 的版本，建议通过 rustup 升级至最新版：

rustup update

或者通过 rustup default nightly 切换到每日构建版。

代码运行效果：

[mengyyy]

fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("at the end: x = {:?}, y = {:?}", x, y);
}

如果 x 的值是 None 而不是 Some(5)，头两个分支的模式不会匹配，所以会匹配模式 _。这个分支的模式中没有引入变量 x，所以此时表达式中的 x 会是外部没有被覆盖的 x，也就是 Some(5)。

这里是不是说的逻辑有问题？ x不可能同时为Some(5)和None吧
x为None时就应该匹配最后一个默认条件

[mengyyy]

fn main() {
    let x = Some(5);
    let y = 10;
    let c: Option<i32> = None;

    match c {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("at the end: x = {:?}, y = {:?}", x, y);
}

[jinliming2]

看起来是的，表达有点问题，这里是假设 x 为 None，所以表达式中的 x 是外部没有被覆盖的 x，结果应该是 None

[cloudscola]

感觉是有问题，但是作者想表达的意思是 match语句里的变量如果没被覆盖，还是会从代码块外读取

[rtpacks]

属性条件与属性变量 y: y @ 条件，条件即模式

复杂类型 | 基本类型 数据的绑定 p @ 模式。

任何一个匹配都可以写成这种形式：p:? p @ 模式，变量匹配时不需要p:，具体的变量属性时需要p:，如果是if let ，注意等号，其实等号也就是match帮我们完成的工作。

[lizhiyu-me]

很灵活,很强大

[einQimiaozi]

let arr: &[u16] = &[114, 514];

if let [x, ..] = arr {
assert_eq!(x, &114);
}

if let &[.., y] = arr {
assert_eq!(y, 514);
}

这么臭的数组有匹配的必要吗（半恼）

[Joy-Panda]

哪儿臭了？

[duanyuluo]

@einQimiaozi，如果不这么做，就必须大量使用vec[index]，这其实是rust等现代语言不推荐的。

[JoshuaGhost]

请问臭数组的第一个模式匹配哪里，为什么114前面要加一个&？这是&[114, ]的语法糖么？

[JoshuaGhost]

哦抱歉是我理解错了，没注意到第一个模式匹配是
if let [x, ...] = arr
第二个是
if let &[..., Y] = arr
那么问题又来了，数组里面的i32是实现了copy trait的，为什么这里的借用也需要&114？

[ajn404]

if let 好像没有守卫匹配的语法

[0xDamn]

if let 匹配单分支就没有必要加这个语法了吧，如果想追加条件在代码块里面加就好了
用if let 改写下书里举的守卫匹配的例子

fn main() {
    let s = Some(4);

    if let Some(x) = s {
        if x < 5 {
            println!("less than five: {}", x)
        } else {
            println!("{}", x)
        }
    } else {
        ()
    }
}

[duanyuluo]

if let 是为了避免复杂的match，你这种情况不如用match更方便：
fn main() {
let s = Some(4);
match s {
Some(x) if x < 5 => println!("less than five: {}", x),
Some(x) => println!("{}", x),
None => println!(""),
}
}

[duanyuluo]

If you like if let... can write codes like below...
fn main() {
let s = Some(4);

if let Some(x@ ..=5) = {
    println!("less than five: {}", x);
}

}

[goodDB]

@duanyuluo

    if let Some(x @ ..=5) = s {
        println!("less than five: {}", x);
    };

少写了 = s

[JackCCCCheung]

懵了😂

[TLinz]

let arr: [u16; 2] = [114, 514]; 哈哈

[TsGanT]

enum Message {
Hello { id: i32 },
}

let msg = Message::Hello { id: 5 };

match msg {
Message::Hello { id: id_variable @ 3..=7 } => {
println!("Found an id in range: {}", id_variable)
},
Message::Hello { id: 10..=12 } => {
println!("Found an id in another range")
},
Message::Hello { id } => {
println!("Found some other id: {}", id)
},
}
这个跟我用守卫匹配有啥区别？
比如：
enum Message {
Hello {id:i32},
}

fn main() {
let msg = Message::Hello { id: 5 };
match msg {
Message::Hello {id} if id>2 => {
print!("{}\n", id)
},
_ => {
println!("Nothing")
}
}
}

[TsGanT]

enum Message {
    Hello { id: i32 },
}

let msg = Message::Hello { id: 5 };

match msg {
    Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable)
    },
    Message::Hello { id: 10..=12 } => {
        println!("Found an id in another range")
    },
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}
上面这个跟我下面这个用守卫模式有啥区别吗？

enum Message {
    Hello {id:i32},
}

fn main() {
    let msg = Message::Hello { id: 5 };
    match msg {
        Message::Hello {id} if id>2 => {
            print!("{}\n", id)
        },
        _ => {
            println!("Nothing")
        }
    }
}

[0xDamn]

区别：

• 性能差：多了一次变量绑定，多了一次条件判断
• 代码可读性差：下面的代码相当于把枚举类型匹配和里面结构体成员值的匹配，这样的话前者模式匹配就比较鸡肋了，因为永远可以匹配到msg，这样的匹配好比if true { if id > 2 { ... }}，正确但不简洁。

[wenli7363]

太复杂了吧..........

[kkkkabuto]

这么臭的数组真的需要解构嘛（恼）

[madjxatw]

说实话，语法设计的并不直观。

[smh2028]

看到这里,我只想说这语法好像有点大病,太饶了

[codecoron]

这一章更多是字典书，需要的时候再回来查阅！

[Skyfacon]

打卡学习

[Dmcz]

解构数组这一段建议调整一下，强调一下区别与原因。
Array是定长，长度在编译时是已知的，所以可以直接解构。
Slice不定长，所以需要用match语句根据运行时实际的内容解构。
而..是省略不需要在意得元素，无论是解构array还是slice中都能使用

😂这里想了好久

[GangJust]

炸裂，这个 @ 太抽象了。。。

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // 绑定@的基本使用
    let p = Point { x: 3, y: 2 };
    match p {
        // 将范围可能是 10~20 的 y 绑定到 y1，此时的匹配值是: x任意值，y的取值为10~20
        Point { x, y: y1 @ 10..=20 } => {
            println!("x: {}, y: {}", x, y1);
        }
        _ => {
            println!("not match");
        }
    }

    let p1 = Point { x: 33, y: 22 };
    // let Point { x, y } = p1; // 解构
    let p_at @ Point { x: x1, y: y1 } = p1; //这里首先对 p1 进行解构，将33绑定到x1变量，22绑定到y1变量，然后再通过@绑定到p_at
    println!("x1 = {}, y1 = {}", x1, y1); // 这里的x1，y1是上一行解构出来的
    println!("p_at = {:?}", p_at);

    let tuple = (String::from("value1"), String::from("value2"));

    let t_at @ (t1, t2) = &tuple;
    // let t_ref = &tuple;
    // let (t1, t2) = t_ref;

    println!("t1 = {}, t2 = {}", t1, t2);
    println!("t_at.0 = {}, t_at.1 = {}", t_at.0, t_at.1);
    // println!("t_ref.0 = {}, t_ref.1 = {}", t_ref.0, t_ref.1);
}

[Pro741]

建议将@句法放到 匹配命名变量 后面, 把 variable @ subpattern 句法看成变量模式下嵌套一个子模式比较更好理解一点.

[chromon]

好难啊，记不住都~

[vince-1998]

炸裂

[Lixuhuilll]

解构不定长数组少了一种用法，这种用法对于减少嵌套层数很有用

fn main() {
    let arr: &[i32] = &[1, 2];

    let [x, y] = arr else {
        panic!();
    };

    println!("x:{x}, y:{y}");
}

[ceyyso163]

解构结构体和元组那里的例子容易误会，且不好理解，建议改成这样：
struct Point {
x: i32,
y: i32,
}
let ((feet, inches), Point {x: a, y: b}) = ((3, 10), Point { x: 3, y: -10 });
println!("{},{},{},{}", a, b);

[JavaZeroo]

fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }

    println!("at the end: x = {:?}, y = {:?}", x, y);
}

这段代码中Some(y) => println!("Matched, y = {:?}", y),，Some(y)会被匹配到，会打印出"Matched, y = 5"

但是如果我希望打印出"Matched, y = Some(5)" 应该怎么写呢？（我希望匹配到Some，同时又希望保留原来的结构体）

[JavaZeroo]

懂了
Some(y) 改为 Some(_)

[HwJhx]

fn main() {
let x = Some(5);
let y = 10;

match x {
    Some(50) => println!("Got 50"),
    Some(y) => println!("Matched, y = {:?}", y),
    _ => println!("Default case, x = {:?}", x),
}

println!("at the end: x = {:?}, y = {:?}", x, y);

}

"如果 x 的值是 None 而不是 Some(5)，头两个分支的模式不会匹配，所以会匹配模式 _。这个分支的模式中没有引入变量 x，所以此时表达式中的 x 会是外部没有被遮蔽的 x，也就是 None" 这句话怎么理解？ 之前提到了y是新的变量，会匹配x的所有值，为何不是打印println!("Matched, y = {:?}", y)？ 是不是因为None为Option中的一个特殊值？

[Octavio000416]

let arr: &[u16] = &[114, 514];

if let [x, ..] = arr {
    assert_eq!(x, &114);
}

这里已知 arr 是一个 &[u16]，但是 if let [x, ..] = arr 中左侧的匹配模式是一个数组
那么我有点不解的是，数组为什么能和 &[u16] 进行匹配并发生后续的解构赋值呢？