模式匹配
- 模式匹配通常由一下组件组成：
字面量。
解构的数组、枚举、结构体或者元组。
变量。
通配符
占位符。
知识汇总
模式的不可失败性和可失败性
- 模式可以被分为不可失败(irrefutable) 和可失败(refutable)两种类型。
- 例如 let x = 5; 中的 x 便是不可失败模式，因为它能够匹配表达式右侧的所有可能的返回值。
- 例如 if let Some(x) = a_value 中的 Some(x) 便是可失败模式，如果 a_value 变量的值时 None 而不是 Some，那么表达式左侧的Some(x) 模式就会发生不匹配。
- 了解这些概念十分重要，比如 let Some(x) = a_value 就会造成编译困扰，因为这个表达式是可失败的那么就要放到 if 中去。
if let 表达式
- 举例：
fn main() {
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age : Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {}, as the background", color);
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
}
}
while let 条件循环模式匹配
- 例子：while let 会反复执行同一个模式匹配直到出现失败的情况。
fn main() {
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(s) = stack.pop() {
println!("Stack value : {}", s);
}
}
for 循环进行元祖填充
- 例子：注意不要忘记调用 enumerate 生成一个元祖迭代器
fn main() {
let v = vec!["a", "b", "c"];
for (index, value) in v.iter().enumerate() {
println!("index : {}, value : {}",index, value );
}
}
let 关键字本身就是一种模式匹配的方式
- 例子：
// 如果模式元素中的数量与元祖的数量不符，那么就会导致匹配失败。
let (x, y, z) = (1, 2, 3);
// 如果确实有的不需要，可以通过 _ 或者 .. 进行省略
let (x, y, _) = (1, 2, 3);
函数参数也是模式匹配
- 可以看到模式匹配无处不在，函数的参数也是模式匹配。
- 例子：
// 实际上定义了一个元祖参数
fn print_coordinates(&(x, y): &(i32, i32)) {
println!(" Current location : ({}, {})", x, y);
}
fn main() {
let point = (55, 33);
print_coordinates(&point);
}
匹配字面量
- 例子：
fn main() {
let x = 1 ;
match x {
1 => {println!("One"); },
2 => {println!("Two"); },
// 注意下面必须加上如果不加会提示没有穷尽所有解
_ => {println!("Other"); },
}
}
匹配命名变量
- 例子：
fn main() {
let x = Some(5);
let y = 10 ;
match x {
Some(50) => println!("Get 50"),
Some(y) => println!("Matched, y = {:?}", y ),
_ => println!("Default case, x = {:?}", x),
}
println!("at the end : x = {:?}, y = {:?}", x, y);
}
多重匹配
- 例子：
fn main() {
let x = 1 ;
match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything."),
}
}
使用 ... 来匹配区间
- 例子：
fn main() {
let x = 7;
match x {
1 ... 9 => println!("one through nine"),
3 => println!("three"),
_ => println!("anything."),
}
}
使用 ..= 来匹配字符区间
- 例子：
fn main() {
let x = 'c';
match x {
'a' ..= 'd' => println!("a | b | c | d"),
'f' ..= 'i' => println!("f | g | h | i"),
_ => println!("anything."),
}
}
使用解构来分解值（分解结构）
- 例子：
fn main() {
struct Point {
x: i32,
y: i32,
}
let point = Point {
x: 32,
y: 66
};
// 解构
let Point {x : a, y : b } = point;
println!("x:{} , y:{}", a, b);
}
稍稍复杂一点的match 匹配
- 看了这个例子突然感觉模式匹配很有用，会的：
fn main() {
struct Point {
x: i32,
y: i32,
}
let point = Point {
x: 0,
y: 7
};
// 进行更复杂一点的模式匹配
match point {
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),
}
}
解构嵌套的结构体和枚举：
- 例子：
enum Color {
Rgb (i32,i32,i32),
Hvs (i32,i32,i32),
}
enum Message {
Quit,
Write(String),
ChangeColor(Color),
}
fn main() {
let msg = Message::ChangeColor(Color::Rgb(6,6,6));
match msg {
Message::ChangeColor(Color::Rgb(r,g,b)) => {
println!("r={},g={},b={}", r,g,b);
},
Message::ChangeColor(Color::Hvs(h,v,s)) => {
println!("h={},v={},s={}", h,v,s);
},
_ => {}
}
}
使用 _ (下划线) 忽略变量值时需要特别注意的一个问题
- 例子，错误的
fn main() {
let s = Some(String::from("Hello."));
if let(_s) = s {
println!("Hello , into there.")
}
// 这段代码编译不过去，虽然 _s 但是所有权仍然会转移
println!("s value is : {:?} ", s);
}
- 例子，正确的，_ 单纯的下滑线就不会造成所有权转移，稍稍修改一下。
fn main() {
let s = Some(String::from("Hello."));
// 修改一下这里，去掉 _ 后面的任何值，所有权就不会转移。
if let(_) = s {
println!("Hello , into there.")
}
println!("s value is : {:?} ", s);
}
使用 .. (双点) 忽略匹配值
- 例子：
struct Point {
x: i32, y:i32 , z:i32,
}
fn main() {
let p = Point {x:3,y:4,z:5};
// 如果只是想匹配x 可以使用双点语法。
let Point{x, ..} = p;
assert_eq!(3, x);
}
为了匹配更复杂的模式可以使用match guard
- 就是在模式匹配中新增一个 if 条件，举例：
fn main() {
let num = Some(4);
match num {
Some(x) if x < 5 => { println!("Num {} less than five. ", x) },
Some(x) => { println!("Num is {} . ", x) },
None => {},
}
}
- 注意一个情况：
match x {
4 | 5 | 6 if y => { ... }
}
实际上等于
match x {
(4 | 5 | 6) if y => { ... }
// 而不是
4 | 5 | (6 if y) => { ... }
}
模式匹配中的绑定
- 有些范围匹配即便成功了，我们也无法捕获到底是什么值匹配成功的。
- 这时候就需要在匹配中绑定变量需要通过 @ 运算符。
fn main() {
enum Message {
Hello {id: i32}
}
let msg = Message::Hello {id: 5};
match msg {
// 注意这里，如果不用 id_variable@ 进行变量捕获，下面的println 就无法直到具体的值是什么。
Message::Hello {id: id_variable@ 3..=7} => {
println!("Found an id in range : {} ", id_variable);
},
Message::Hello {id:10...12} => {
println!("Found id between 10 to 12");
},
Message::Hello {id} => {
println!("Found some other id : {}", id);
},
}
}
结束
- 感谢阅读，See you at work.
