rust-course/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上那么因为匹配守卫的关系，这一分支就不匹配了，这时应该匹配第二还是第三个分支。

[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特征的,不涉及所有权问题.

[PPPPigggg]

match x {
    Some(s) if { drop(s); false } => {} // 移除 s
    _ => {}
}
println!("{:?}", x); // 错误：x 已被部分 Move

[potatoshred]

当使用守卫（if 条件）时，如果条件中需要借用该值，那么编译器会聪明地采用一个临时的引用，而不是移动所有权。

[potatoshred]

所有权只会在​​实际进入分支的代码块时​​转移。当守卫条件失败时，所有权不会被移入该分支的 s，因此后续分支可以继续尝试匹配。

[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？

[gldsly]

😂我给你改改，哈哈哈

fn main() {
    let arr: [u16; 2] = [114, 514];

    let [x, ..] = arr;
    assert_eq!(x, 114);
    
    let [.., y] = arr;
    assert_eq!(y, 514);
}

[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]

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

[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中的一个特殊值？

[CamaroW]

Option 枚举里包含 Some 和 None 两种值，x = None 时它的类型是 Option::None，x = Some(5) 时它的类型是 Option::Some，本质上都是 Option 类型。这里 match 匹配的就是 Option 类型下的不同情况。

• 第一分支：Some(50) 这个模式就限制了“只有 x = Some(50) 才会被匹配”。
• 第二分支：Some(y) 这个模式创建了一个 y 变量（和外面的 y = 10 的 y 没有任何关系）。因为这个模式没有限制/声明 y 具体是什么，所以任何 Some(i32) 值都会被成功匹配到这个模式（如果是 Some(50) 的话，也会匹配这个 Some(y)，但是因为它会在分支一里就被匹配了，所以并不会真的匹配分支二并执行分支二的表达式）（这里是 i32 因为 Rust 默认整数类型是 i32，不过这个 i32 的点是我猜的，也许实际情况更复杂）（如果想要声明 y 具体是什么，同时还想保留这个 y 变量，那么我认为可以用这篇最后教的@绑定，比如 Some(y @ 3)，这样和直接用 Some(3) 的区别就是还额外有了一个可以用的变量 y）。
• 第三分支：用 _ 就代表是“其余所有情况”，但其实其余所有情况只剩下了 x = None 的情况，因为只要 x 是 Some(某个值)，就一定会在之前被匹配到（如果是 Some(50)，就会匹配第一分支，如果是 Some(其他的)，就会匹配第二分支，并且 y = 其他的。

[Octavio000416]

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

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

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

[CamaroW]

最后@绑定那里

Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable)
    },

是不是也可以用

Message::Hello { id: id_variable } if (3 <= id_variable) && (id_variable <= 7) => {
        println!("Found an id in range: {}", id_variable)
    },

达到同样的目的，只不过啰嗦一点。

[B41dr]

严格一点，RGB 的定义就是 3 x 8 ，定义成 i32 是否合适

[vbingbingv]

这已经是我两年内第五次学习Rust了，都是从头重新学的2333。上班族太苦逼了

[vbingbingv]

那我是不是可以

let y @ 5

来进行变量绑定？

[potatoshred]

let a @ b @ c = 5;

[fuochai]

可惜牛客的rust才到1.44

[xiaokangwang1992]

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

fn main() {
    // 绑定新变量 `p`，同时对 `Point` 进行解构
    let p @ Point {x: px, y: py } = Point {x: 10, y: 23};
    println!("x: {}, y: {}", px, py);
    println!("{:?}", p);


    let point = Point {x: 11, y: 5};
    if let p @ Point {x: 10, y} = point {
        println!("x is 10 and y is {} in {:?}", y, p);
    } else {
        println!("x was not 10 :({:?})", p);
    }
}

输出：

x: 10, y: 23 
Point { x: 10, y: 23 }
x was not 10 :(Point { x: 10, y: 23 })

导致最后打印的原因是：x was not 10 :(Point { x: 10, y: 23 })

1. 变量混淆：else分支中打印的p不是来自if let模式匹配，而是来自前面定义的let p @ Point {x: px, y: py } = Point {x: 10, y: 23};语句。
2. 作用域问题：在Rust中，if let中的p只在匹配成功时才会绑定，且作用域仅限于if块内部。当匹配失败时，执行else分支，这时使用的p是外部作用域中的变量（值为Point { x: 10, y: 23 }）。

[yyyyysssssi7606]

特性太多了，记不住那么多

[cfanlei]

已经不知道几遍了。 再看到等未来需要时 再回来看看 ～_～

[loccyliu]

感觉到难度了，@绑定理解不了

[hengzhang941235]

书中的原话：

字符和数字值是 Rust 中仅有的可以用于判断是否为空的类型。

更准确的表达应该是：

字符类型和数值类型是 Rust 中仅有能够形成编译器可验证的连续区间（range）的类型，因此编译器可以在编译期判断该区间是否为空，所以它们也是唯一允许用于 match 范围模式（range pattern）的类型。

[chuwj]

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

if let [x, ..] = arr {
assert_eq!(x, &114); //这里在数字前面加&，不好理解
}

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

let arr: &[u16] = &[];

assert!(matches!(arr, [..]));
assert!(!matches!(arr, [x, ..]));