变量绑定与解构

绑定和可变性

  1. 🌟 变量只有在初始化后才能被使用
2. // 修复下面代码的错误并尽可能少的修改
3. fn main() {
4. let x: i32; // 未初始化，但被使用
5. let y: i32; // 未初始化，也未被使用
6. println!("x is equal to {}", x);
7. }
  1. 🌟🌟 可以使用 mut 将变量标记为可变
2. // 完形填空，让代码编译
3. fn main() {
4. let __ = 1;
5. __ += 2;

7. println!("x = {}", x);
8. }

变量作用域

  1. 🌟 作用域是一个变量在程序中能够保持合法的范围
2. // 修复下面代码的错误并使用尽可能少的改变
3. fn main() {
4. let x: i32 = 10;
5. {
6. let y: i32 = 5;
7. println!("x 的值是 {}, y 的值是 {}", x, y);
8. }
9. println!("x 的值是 {}, y 的值是 {}", x, y);
10. }
  1. 🌟🌟
1. // 修复错误
2. fn main() {
3. println!("{}, world", x);
4. }

6. fn define_x() {
7. let x = "hello";
8. }

变量遮蔽( Shadowing )

  1. 🌟🌟 若后面的变量声明的名称和之前的变量相同，则我们说：第一个变量被第二个同名变量遮蔽了( shadowing )
2. // 只允许修改 `assert_eq!` 来让 `println!` 工作(在终端输出 `42`)
3. fn main() {
4. let x: i32 = 5;
5. {
6. let x = 12;
7. assert_eq!(x, 5);
8. }

10. assert_eq!(x, 12);

12. let x = 42;
13. println!("{}", x); // 输出 "42".
14. }
  1. 🌟🌟 修改一行代码以通过编译
2. fn main() {
3. let mut x: i32 = 1;
4. x = 7;
5. // 遮蔽且再次绑定
6. let x = x;
7. x += 3;

9. let y = 4;
10. // 遮蔽
11. let y = "I can also be bound to text!";
12. }

未使用的变量

  1. 使用以下方法来修复编译器输出的 warning :

  2. 🌟 一种方法

  3. 🌟🌟 两种方法

注意: 你可以使用两种方法解决，但是它们没有一种是移除 let x = 1 所在的代码行

2. fn main() {
3. let x = 1;
4. }

6. // compiler warning: unused variable: `x`

变量解构

  1. 🌟🌟 我们可以将 let 跟一个模式一起使用来解构一个元组，最终将它解构为多个独立的变量

提示: 可以使用变量遮蔽或可变性

2. // 修复下面代码的错误并尽可能少的修改
3. fn main() {
4. let (x, y) = (1, 2);
5. x += 2;

7. assert_eq!(x, 3);
8. assert_eq!(y, 2);
9. }

解构式赋值

该功能于 Rust 1.59 版本引入：你可以在赋值语句的左式中使用元组、切片或结构体进行匹配赋值。

  1. 🌟🌟

Note: 解构式赋值只能在 Rust 1.59 或者更高版本中使用

2. fn main() {
3. let (x, y);
4. (x,..) = (3, 4);
5. [.., y] = [1, 2];
6. // 填空，让代码工作
7. assert_eq!([x,y], __);
8. }

答案 在 solutions 下面