Rust学习：8_模式匹配
前言
为了学习Rust，阅读了github上的Rust By Practice电子书，本文章只是用来记录自己的学习过程，感兴趣的可以阅读原书，希望大家都能掌握Rust！
练习
match, matches! 和 if let
match
1.🌟🌟
// 填空
enum Direction {
East,
West,
North,
South,
}
fn main() {
let dire = Direction::South;
match dire {
Direction::East => println!("East"),
__ => { // 在这里匹配 South 或 North
println!("South or North");
},
_ => println!(__),
};
}
✅修改：
// 填空
enum Direction {
East,
West,
North,
South,
}
fn main() {
let dire = Direction::South;
match dire {
Direction::East => println!("East"),
Direction::South | Direction::North => { // 在这里匹配 South 或 North
println!("South or North");
},
_ => println!("West"),
};
}
2.🌟🌟
match 是一个表达式，因此可以用在赋值语句中
fn main() {
let boolean = true;
// 使用 match 表达式填空，并满足以下条件
//
// boolean = true => binary = 1
// boolean = false => binary = 0
let binary = __;
assert_eq!(binary, 1);
}
✅修改：
fn main() {
let boolean = true;
// 使用 match 表达式填空，并满足以下条件
//
// boolean = true => binary = 1
// boolean = false => binary = 0
let binary = match boolean{
true => 1,
_ => 0
};
assert_eq!(binary, 1);
}
3.🌟🌟
使用 match 匹配出枚举成员持有的值
// 填空
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
assert_eq!(a, 1);
assert_eq!(b, 3);
},
Message::ChangeColor(_, g, b) => {
assert_eq!(g, __);
assert_eq!(b, __);
}
__ => println!("no data in these variants")
}
}
✅修改：
// 填空
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{x:a, y:b} => { // 这里匹配 Message::Move
assert_eq!(a, 1);
assert_eq!(b, 3);
},
Message::ChangeColor(r, g, b) => {
assert_eq!(g, 255);
assert_eq!(b, 0);
},
_ => println!("no data in these variants")
}
}
matches!
matches! 看起来像 match, 但是它可以做一些特别的事情
Macro [core]::[matches]
macro_rules! matches {
($expression:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => { ... };
}
返回给定表达式是否匹配任何给定模式。
就像在match表达式中一样，模式之后可以选择跟随if 一个可以访问由模式绑定的名称的保护表达式。
例子
let foo = 'f';
assert!(matches!(foo, 'A'..='Z' | 'a'..='z'));
let bar = Some(4);
assert!(matches!(bar, Some(x) if x > 2));
4.🌟🌟
fn main() {
let alphabets = ['a', 'E', 'Z', '0', 'x', '9' , 'Y'];
// 使用 `matches` 填空
for ab in alphabets {
assert!(__)
}
}
✅修改：
fn main() {
let alphabets = ['a', 'E', 'Z', '0', 'x', '9' , 'Y'];
// 使用 `matches` 填空
for ab in alphabets {
assert!(matches!(ab, 'a'..='z' | 'A'..='Z' | '0'..='9'))
}
}
5.🌟🌟
enum MyEnum {
Foo,
Bar
}
fn main() {
let mut count = 0;
let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
for e in v {
if e == MyEnum::Foo { // 修复错误，只能修改本行代码
count += 1;
}
}
assert_eq!(count, 2);
}
✅修改：
enum MyEnum {
Foo,
Bar
}
fn main() {
let mut count = 0;
let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
for e in v {
if matches!(e, MyEnum::Foo) { // 修复错误，只能修改本行代码
count += 1;
}
}
assert_eq!(count, 2);
}
if let
在有些时候, 使用 match 匹配枚举有些太重了，此时 if let 就非常适合.
6.🌟
fn main() {
let o = Some(7);
// 移除整个 `match` 语句块，使用 `if let` 替代
match o {
Some(i) => {
println!("This is a really long string and `{:?}`", i);
}
_ => {}
};
}
✅修改：
fn main() {
let o = Some(7);
if let Some(x) == o{
println!("This is a really long string and `{:?}`", x);
}
}
7.🌟🌟
// 填空
enum Foo {
Bar(u8)
}
fn main() {
let a = Foo::Bar(1);
__ {
println!("foobar 持有的值是: {}", i);
}
}
✅修改：
// 填空
enum Foo {
Bar(u8)
}
fn main() {
let a = Foo::Bar(1);
if let Foo::Bar(i) = a{
println!("foobar 持有的值是: {}", i);
}
}
8.🌟🌟
enum Foo {
Bar,
Baz,
Qux(u32)
}
fn main() {
let a = Foo::Qux(10);
// 移除以下代码，使用 `match` 代替
if let Foo::Bar = a {
println!("match foo::bar")
} else if let Foo::Baz = a {
println!("match foo::baz")
} else {
println!("match others")
}
}
✅修改：
enum Foo {
Bar,
Baz,
Qux(u32)
}
fn main() {
let a = Foo::Qux(10);
match a{
Foo::Bar => println!("match foo::bar"),
Foo::Baz => println!("match foo::baz"),
_ => println!("match others")
};
}
变量遮蔽( Shadowing )
9.🌟🌟
// 就地修复错误
fn main() {
let age = Some(30);
if let Some(age) = age { // 创建一个新的变量，该变量与之前的 `age` 变量同名
assert_eq!(age, Some(30));
} // 新的 `age` 变量在这里超出作用域
match age {
// `match` 也能实现变量遮蔽
Some(age) => println!("age 是一个新的变量，它的值是 {}",age),
_ => ()
}
}
✅修改：
// 就地修复错误
fn main() {
let age = Some(30);
if let Some(age) = age { // 创建一个新的变量，该变量与之前的 `age` 变量同名
assert_eq!(age, 30);
} // 新的 `age` 变量在这里超出作用域
match age {
// `match` 也能实现变量遮蔽
Some(age) => println!("age 是一个新的变量，它的值是 {}",age),
_ => ()
}
}
模式
1.🌟🌟
使用 | 可以匹配多个值, 而使用 ..= 可以匹配一个闭区间的数值序列
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")
}
}
}
✅修改：
fn main() {}
fn match_number(n: i32) {
match n {
// 匹配一个单独的值
1 => println!("One!"),
// 使用 `|` 填空，不要使用 `..` 或 `..=`
2..=5 => println!("match 2 -> 5"),
// 匹配一个闭区间的数值序列
6..=10 => {
println!("match 6 -> 10")
},
_ => {
println!("match 11 -> +infinite")
}
}
}
2.🌟🌟 🌟
@ 操作符可以让我们将一个与模式相匹配的值绑定到新的变量上
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),
}
}
✅修改：
struct Point {
x: i32,
y: i32,
}
fn main() {
// 填空，让 p 匹配第二个分支
let p = Point { x: 1, y: 10 };
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),
}
}
3.🌟🌟 🌟
// 修复错误
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),
}
}
✅修改：
// 修复错误
enum Message {
Hello { id: i32 },
}
fn main() {
let msg = Message::Hello { id: 5 };
match msg {
Message::Hello {
id: 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),
}
}
4.🌟🌟
匹配守卫（match guard）是一个位于 match 分支模式之后的额外 if 条件，它能为分支模式提供更进一步的匹配条件。
// 填空让代码工作，必须使用 `split`
fn main() {
let num = Some(4);
let split = 5;
match num {
Some(x) __ => assert!(x < split),
Some(x) => assert!(x >= split),
None => (),
}
}
✅修改：
// 填空让代码工作，必须使用 `split`
fn main() {
let num = Some(4);
let split = 5;
match num {
Some(x) if x < split => assert!(x < split),
Some(x) => assert!(x >= split),
None => (),
}
}
5.🌟🌟 🌟
使用 .. 忽略一部分值
// 填空，让代码工作
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);
}
}
}
✅修改：
// 填空，让代码工作
fn main() {
let numbers = (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048);
match numbers {
(first,..,last) => {
assert_eq!(first, 2);
assert_eq!(last, 2048);
}
}
}
6.🌟🌟
使用模式 &mut V 去匹配一个可变引用时，你需要格外小心，因为匹配出来的 V 是一个值，而不是可变引用
// 修复错误，尽量少地修改代码
// 不要移除任何代码行
fn main() {
let mut v = String::from("hello,");
let r = &mut v;
match r {
&mut value => value.push_str(" world!")
}
}
✅修改：
// 修复错误，尽量少地修改代码
// 不要移除任何代码行
fn main() {
let mut v = String::from("hello,");
let r = &mut v;
match r {
// The type of value is &mut String
value => value.push_str(" world!")
}
}
1844
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
