8.Rust模式解构
模式解构—Pattern Destructure，其对应的就是模式构造，因此模式解构是将原本组合起来的结构分解为单独的、局部的、原始的部分。
1.模式解构示例
我们之前在学习tuple时，写过类似以下例子：
fn main() {
let t = (1, 's', "白质".to_string());
let (t_one, t_two, t_tree) = t;
println!("t_one: {}, t_two: {}, t_tree: {}", t_one, t_two, t_tree);
}
运行结果：
t_one: 1, t_two: s, t_tree: 白质
以上例子就是典型的“模式解构”。
let t = (1, 's', "白质".to_string()); //将三个元素组合到一起形成一个tuple
let (t_one, t_two, t_tree) = t; //刚好与以上相反，把一个组合数据结构，拆解成三个不同的变量
下面再举一个稍复杂些的例子：
struct A(i32, String);
struct B {
data1 : A,
data2 : bool
}
fn main() {
let xb = B { data1 : A(32, "模式".to_string()), data2 : true };
let B{
data1 : A(val1, val2),
data2 : val3
} = xb;
println!("val1: {}, val2: {}, val3: {}", val1, val2, val3);
}
运行结果：
val1: 32, val2: 模式, val3: true
模式结构不仅可以发生在let语句中，还可以发生在match、if let、while let、函数调用、闭包调用等情境中。
下面将逐一介绍。
2.match
我们从最开始的猜数字就一直在接触match，这对我们来说再熟悉不过了。
通过枚举来举一个例子：
enum data_type {
Int(i32),
Float(f32),
Str(String),
Char(char)
}
fn print_data_type(data : data_type) {
match data {
data_type::Int(val) => {
println!("Int: {}", val);
}
data_type::Float(val) => {
println!("Float: {}", val);
}
data_type::Str(val) => {
println!("Str: {}", val);
}
data_type::Char(val) => {
println!("Char: {}", val);
}
}
}
fn main() {
let a = data_type::Int(1);
let b = data_type::Float(3.3);
let c = data_type::Str("牛逼".to_string());
let d = data_type::Char('s');
print_data_type(a);
print_data_type(b);
print_data_type(c);
print_data_type(d);
}
运行结果：
Int: 1
Float: 3.3
Str: 牛逼
Char: s
但是如果我们把上面的Char分支删除：
match data {
data_type::Int(val) => {
println!("Int: {}", val);
}
data_type::Float(val) => {
println!("Float: {}", val);
}
data_type::Str(val) => {
println!("Str: {}", val);
}
}
编译出错：
error[E0004]: non-exhaustive patterns: `Char(_)` not covered
--> src\main.rs:9:11
|
1 | / enum data_type {
2 | | Int(i32),
3 | | Float(f32),
4 | | Str(String),
5 | | Char(char)
| | ---- not covered
6 | | }
| |_- `data_type` defined here
...
9 | match data {
| ^^^^ pattern `Char(_)` not covered
non-exhaustive patterns:不详尽的模式、不完整的模式
Rust要求match需要对所以情况做完整的、无遗漏的匹配。exhaustive是Rust模式匹配的重要特定。
我们还可以通过下划线来表达其他情况：
fn print_data_type(data : data_type) {
match data {
data_type::Int(val) => {
println!("Int: {}", val);
}
data_type::Float(val) => {
println!("Float: {}", val);
}
_ => {
println!("others");
}
// data_type::Str(val) => {
// println!("Str: {}", val);
// }
// data_type::Char(val) => {
// println!("Char: {}", val);
// }
}
}
运行结果：
Int: 1
Float: 3.3
others
others
因此，如果多个项目之间存在依赖关系，在上游库中对一个enum添加成员，是一个破坏兼容性的行为。增加成员后，很有可能导致下游的，atch语句编译出错。
为了解决以上问题，Rust提供了一个叫non_exhaustive的功能：
#[non_exhaustive]
pub enum A {
//就不详细写了
}
这样下游项目中就必须使用下划线才能完整匹配。
下划线还能够用在模式匹配的其他地方，用来表示一个占位符，虽然匹配到了但是忽略它的值的情况：
fn main() {
let t = (1, 's', "Rust编程之路");
let (a, _, b) = t;
println!("a: {}", a);
println!("b: {}", b);
}
运行结果：
a: 1
b: Rust编程之路
函数参数就具备模式解构的能力：
fn func((a, _, b) : (i32, char, &str)) {
println!("a: {}", a);
println!("b: {}", b);
}
fn main() {
let t = (1, 's', "Rust编程之路");
func(t);
}
运行结果：
a: 1
b: Rust编程之路
3.if-let和while-let
我们之前在使用Option时，如果需要取出里面的值，需要做以下操作：
match data {
Some(x) => {
func(x);
}
_ => {}
}
这样做是必需的，但是比较麻烦。我们还可以采用以下方式：
if data.is_some() {
let x = data.unwrap();
func(x);
}
首先通过is_some判断是Some,然后通过unwrap取出数据。这样好像不是很麻烦，但是需要做两次判断是否有值。
我们可以使用if-let语法：
if let Some(x) = data {
func(x);
}
if-let与match相比的优势在于：match需要完整匹配，而if-let则可以选择匹配感兴趣的某个特定分支，这样比较简单。
同理，while-let是同样的道理，暂不举例了。
4.函数参数模式解构
这个前面已经举过例子了。
5.ref关键字
当我们需要绑定的是被匹配对象的引用时，可以使用ref关键字。
struct A(i32, f32);
fn main() {
let a = A(3, 3.3);
let A(ref x, ref y) = a;
}