01-match, matches! 和 if let

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/pattern-match/match-iflet.html

match, matches! 和 if let

match

🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 填空
enum Direction {
 East,
 West,
 North,
 South,
}

fn main() {
 let dire = Direction::South;
 match dire {
 Direction::East => println!("East"),
 // __ => { // 在这里匹配 South 或 North
 Direction::South | Direction::North => {
 // 在这里匹配 South 或 North
 println!("South or North");
 }
 // _ => println!(__),
 _ => println!("West"),
 };
}

🌟🌟 match 是一个表达式，因此可以用在赋值语句中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


fn main() {
 let boolean = true;

 // 使用 match 表达式填空，并满足以下条件
 //
 // boolean = true => binary = 1
 // boolean = false => binary = 0
 // let binary = __;
 let binary = match boolean {
 true => 1,
 false => 0,
 };

 assert_eq!(binary, 1);
}

🌟🌟 使用 match 匹配出枚举成员持有的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


// 填空
enum Message {
 Quit,
 Move { x: i32, y: i32 },
 Write(String),
 ChangeColor(i32, i32, i32),
}

fn main() {
 let msgs = [
 Message::Quit,
 Message::Move{x:1, y:3},
 Message::ChangeColor(255,255,0)
 ];

 for msg in msgs {
 show_message(msg)
 }
}

fn show_message(msg: Message) {
 match msg {
 // __ => { // 这里匹配 Message::Move
 Message::Move {x:a, y:b} => { // 这里匹配 Message::Move
 assert_eq!(a, 1);
 assert_eq!(b, 3);
 },
 Message::ChangeColor(_, g, b) => {
 // assert_eq!(g, __);
 assert_eq!(g, 255);
 // assert_eq!(b, __);
 assert_eq!(b, 0);
 }
 // __ => println!("no data in these variants")
 _ => println!("no data in these variants")
 }
}

matches!

matches! 看起来像 match, 但是它可以做一些特别的事情

02-模式

Wed, 12 Aug 2026 20:00:00 +0800

内容来源 · Rust By Practice / Rust 语言实战

原文链接: https://practice-rust-zh.beatai.org/pattern-match/patterns.html

模式

🌟🌟 使用 | 可以匹配多个值, 而使用 ..= 可以匹配一个闭区间的数值序列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17



fn main() {}
fn match_number(n: i32) {
 match n {
 // 匹配一个单独的值
 1 => println!("One!"),
 // 使用 `|` 填空，不要使用 `..` 或 `..=`
 __ => println!("match 2 -> 5"),
 // 匹配一个闭区间的数值序列
 6..=10 => {
 println!("match 6 -> 10")
 },
 _ => {
 println!("match 11 -> +infinite")
 }
 }
}

🌟🌟🌟 @ 操作符可以让我们将一个与模式相匹配的值绑定到新的变量上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17



struct Point {
 x: i32,
 y: i32,
}

fn main() {
 // 填空，让 p 匹配第二个分支
 let p = Point { x: __, y: __ };

 match p {
 Point { x, y: 0 } => println!("On the x axis at {}", x),
 // 第二个分支
 Point { x: 0..=5, y: y@ (10 | 20 | 30) } => println!("On the y axis at {}", y),
 Point { x, y } => println!("On neither axis: ({}, {})", x, y),
 }
}

🌟🌟🌟

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19



// 修复错误
enum Message {
 Hello { id: i32 },
}

fn main() {
 let msg = Message::Hello { id: 5 };

 match msg {
 Message::Hello {
 id: 3..=7,
 } => println!("id 值的范围在 [3, 7] 之间: {}", id),
 Message::Hello { id: newid@10 | 11 | 12 } => {
 println!("id 值的范围在 [10, 12] 之间: {}", newid)
 }
 Message::Hello { id } => println!("Found some other id: {}", id),
 }
}

🌟🌟 匹配守卫（match guard）是一个位于 match 分支模式之后的额外 if 条件，它能为分支模式提供更进一步的匹配条件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11



// 填空让代码工作，必须使用 `split`
fn main() {
 let num = Some(4);
 let split = 5;
 match num {
 Some(x) __ => assert!(x < split),
 Some(x) => assert!(x >= split),
 None => (),
 }
}

🌟🌟🌟 使用 .. 忽略一部分值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12



// 填空，让代码工作
fn main() {
 let numbers = (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048);

 match numbers {
 __ => {
 assert_eq!(first, 2);
 assert_eq!(last, 2048);
 }
 }
}

🌟🌟 使用模式 &mut V 去匹配一个可变引用时，你需要格外小心，因为匹配出来的 V 是一个值，而不是可变引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11



// 修复错误，尽量少地修改代码
// 不要移除任何代码行
fn main() {
 let mut v = String::from("hello,");
 let r = &mut v;

 match r {
 &mut value => value.push_str(" world!") 
 }
}

你可以在这里找到答案(在 solutions 路径下)

第8章 模式匹配 on 编程那些事儿

01-match, matches! 和 if let

match, matches! 和 if let

match

matches!

02-模式

模式

第8章模式匹配 on 编程那些事儿