Rust从入门到实战系列二百七十八：变量遮蔽( Shadowing )

🌟🌟
// 就 地 修 复 错 误
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),
_ => ()
}
}
你可以在这里找到答案(在 solutions 路径下)
模式

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”)
   }
   }
   }
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),
   }
   }
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),
   }
   }
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 => (),
   }
   }
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);
   }
   }
   }
6. 🌟🌟 使用模式 &mut V 去匹配一个可变引用时，你需要格外小心，因为匹配出来的 V 是一个值，
   而不是可变引用
   // 修 复 错 误 ， 尽 量 少 地 修 改 代 码
   // 不 要 移 除 任 何 代 码 行
   fn main() {
   let mut v = String::from(“hello,”);
   let r = &mut v;
   match r {
   &mut value => value.push_str(" world!")
   }
   }