Rust从入门到实战系列二百六十五：语句与表达式

示例
fn main() {
let x = 5u32;
let y = {
let x_squared = x * x;
let x_cube = x_squared * x;
// 下 面 表 达 式 的 值 将 被 赋 给 y
x_cube + x_squared + x
};
let z = {
// 分 号 让 表 达 式 变 成 了 语 句 ， 因 此 返 回 的 不 再 是 表 达 式 2 * x 的 值 ， 而 是 语 句 的 值 ()
2 * x;
};
println!(“x is {:?}”, x);
println!(“y is {:?}”, y);
println!(“z is {:?}”, z);
}
练习

1. 🌟🌟
   // 使 用 两 种 方 法 让 代 码 工 作 起 来
   fn main() {
   let v = {
   let mut x = 1;
   x += 2
   };
   assert_eq!(v, 3);
   }
2. 🌟
   fn main() {
   let v = (let x = 3);
   assert!(v == 3);
   }
3. 🌟
   fn main() {
   let s = sum(1 , 2);
   assert_eq!(s, 3);
   }
   fn sum(x: i32, y: i32) -> i32 {
   x + y;
   }
   你可以在这里找到答案(在 solutions 路径下)
   函数
4. 🌟🌟🌟
   fn main() {
   // 不 要 修 改 下 面 两 行 代 码!
   let (x, y) = (1, 2);
   let s = sum(x, y);
   assert_eq!(s, 3);
   }
   fn sum(x, y: i32) {
   x + y;
   }
5. 🌟🌟
   fn main() {
   print();
   }
   // 使 用 另 一 个 类 型 来 替 代 i32
   fn print() -> i32 {
   println!(“hello,world”);
   }
6. 🌟🌟🌟
   // 用 两 种 方 法 求 解
   fn main() {
   never_return();
   }
   fn never_return() -> ! {
   // 实 现 这 个 函 数 ， 不 要 修 改 函 数 签 名!
   }
7. 🌟🌟 发散函数( Diverging function )不会返回任何值，因此它们可以用于替代需要返回任何值的地
   方
   fn main() {
   println!(“Success!”);
   }
   fn get_option(tp: u8) -> Option {
   match tp {
   1 => {
   // TODO
   }
   _ => {
   // TODO
   }
   };
   // 这 里 与 其 返 回 一 个 None， 不 如 使 用 发 散 函 数 替 代
   never_return_fn()
   }
   // 使 用 三 种 方 法 实 现 以 下 发 散 函 数
   fn never_return_fn() -> ! {
   }
8. 🌟🌟
   fn main() {
   // 填 空
   let b = __;
   let _v = match b {
   true => 1,
   // 发 散 函 数 也 可 以 用 于 match 表 达 式 ， 用 于 替 代 任 何 类 型 的 值
   false => {
   println!(“Success!”);
   panic!(“we have no value for false, but we can panic”)
   }
   };
   println!(“Exercise Failed if printing out this line!”);
   }