文章目录
- Rust语言入门第四篇-变量与可变性以及隐藏（Shadowing）
- 概要
- let 关键字
- 自动判断变量类型
- 隐藏（Shadowing）
- let关键字支持的数据类型
- let 关键字声明的变量类型转换
Rust语言入门第四篇-变量与可变性以及隐藏（Shadowing）
概要
在 Rust 中，尽管是强类型语言，但编译器拥有类型推断的能力。这意味着你可以在不显式指定变量类型的情况下声明变量，编译器会根据上下文推断出变量的类型。这样的设计在一定程度上使代码更加简洁，但不会牺牲类型安全性。
let 关键字
在 Rust 中，尽管是强类型语言，但编译器拥有类型推断的能力。这意味着你可以在不显式指定变量类型的情况下声明变量，编译器会根据上下文推断出变量的类型。这样的设计在一定程度上使代码更加简洁，但不会牺牲类型安全性。
在 Rust 中，使用 let 关键字声明的变量默认是不可变的（immutable）。如果需要可变的变量，则需要使用 let mut 来声明。例如：
// 不可变变量 x，类型为 i32，编译器会根据赋值推断出类型为 i32
let x = 5;// 可变变量 y，类型为 i32
let mut y = 10;
强行执行
error[E0384]: cannot assign twice to immutable variable `x`--> src\main.rs:4:5|
3 | let x = 5;| -| || first assignment to `x`| help: consider making this binding mutable: `mut x`
4 | x = 9;| ^^^^^ cannot assign twice to immutable variable原因是 不能为不可变变量x赋值两次
因此，虽然 Rust 具有类型推断的能力，但仍然需要使用 let 或 let mut 显式声明变量，并且编译器会根据上下文进行类型推断，确保代码的类型安全性。
自动判断变量类型
Rust 代码展示了如何使用 let 关键字声明变量并进行赋值，而不显式指定变量类型，让编译器根据赋值的内容自动推断变量的类型。下面是对每个变量的解释：
fn main() {let a = "123"; // 变量 a 的类型是 &str（字符串切片）let b = 123; // 变量 b 的类型是 i32（32 位有符号整数）let c = 123.1; // 变量 c 的类型是 f64（64 位浮点数）let d = true; // 变量 d 的类型是 bool（布尔值）let e = '1'; // 变量 e 的类型是 char（Unicode 字符）println!("{}", { a }); // 打印变量 a 的值println!("{}", { b }); // 打印变量 b 的值println!("{}", { c }); // 打印变量 c 的值println!("{}", { d }); // 打印变量 d 的值println!("{}", { e }); // 打印变量 e 的值
}
在这个示例中，变量的类型是根据赋值的内容自动推断出来的。Rust 的类型推断机制使得代码更加简洁，同时保持了类型安全性，但不会牺牲类型安全性。
隐藏（Shadowing）
在 Rust 中，隐藏（Shadowing）是指在同一作用域内，使用一个新的变量名来覆盖已经存在的同名变量。这与变量的重新赋值不同，因为隐藏创建了一个新的变量，而不是修改原有变量的值。隐藏允许你在同一作用域内使用相同的变量名来引入新值，而无需创建新的作用域。
下面是一个示例说明 Rust 中隐藏的概念：
fn main() {let x = 5; // 声明并初始化变量 x// 使用隐藏创建一个新的变量 ylet y = 10;println!("Before shadowing: x = {}, y = {}", x, y);{let y = x+y;println!("Before shadowing: x = {}, y = {}", x, y);}let x = "hello"; // 隐藏变量 x，并赋予一个新值let y = false; // 隐藏变量 y，并赋予一个新值println!("After shadowing: x = {}, y = {}", x, y);
}
在 Rust 中，使用花括号 {} 创建一个新的作用域（scope）。在你的代码中，{} 中的代码块就是一个新的作用域。在这个作用域内声明的变量 y 与外部作用域中的变量 y 是不同的变量，因为它们位于不同的作用域内。
在这个示例中，我们先声明并初始化了两个变量 x 和 y，然后使用隐藏分别创建了新的变量 x 和 y，并赋予了新的值。在打印变量值时，会分别输出隐藏后的 x 和 y 的值。
隐藏的好处在于可以使用相同的变量名来引入新的值，而不必担心与之前的变量产生冲突。此外，隐藏也能够增强代码的可读性和灵活性。
let关键字支持的数据类型
在 Rust 中，let 变量声明可以支持多种数据类型。下面是一些示例代码，展示了 let 变量声明不同类型的用法：
- 整数类型示例：
// Signed integers
let x: i8 = 10;
let y: i16 = 100;
let z: i32 = 1000;
let w: i64 = 10000;// Unsigned integers
let a: u8 = 10;
let b: u16 = 100;
let c: u32 = 1000;
let d: u64 = 10000;
- 浮点数类型示例：
let x: f32 = 3.14;
let y: f64 = 3.14159265359;
- 布尔类型示例：
let x: bool = true;
let y: bool = false;
- 字符类型示例：
let x: char = 'a';
let y: char = '😀';
- 元组类型示例：
let x: (i32, f64, char) = (42, 3.14, 'a');
- 数组类型示例：
let x: [i32; 5] = [1, 2, 3, 4, 5];
- 切片类型示例：
let x: &[i32] = &[1, 2, 3, 4, 5];
- 字符串类型示例：
let x: &str = "Hello, world!";
let y: String = String::from("Hello, world!");
- 结构体类型示例：
struct Point {x: i32,y: i32,
}let p: Point = Point { x: 10, y: 20 };
- 枚举类型示例：
enum Direction {Up,Down,Left,Right,
}let d: Direction = Direction::Up;
这些示例展示了 let 变量声明不同类型的用法，你可以根据具体的需求选择合适的类型来声明变量。
let 关键字声明的变量类型转换
在 Rust 中，let 关键字用于声明变量。通过 let 关键字声明的变量可以转换为多种类型，具体取决于变量的使用和上下文。下面是一些常见的类型转换：
- 不可变绑定（Immutable Binding）转换为可变绑定（Mutable Binding）：通过使用
mut关键字，可以将不可变绑定转换为可变绑定。例如：
let x = 5; // 不可变绑定
let mut y = x; // 转换为可变绑定
- 从一个类型转换为另一个类型：通过重新赋值或使用类型转换函数，可以将变量从一种类型转换为另一种类型。例如：
let x = 5; // 整数类型
let y = x as f32; // 将整数类型转换为浮点数类型
- 引用类型转换为可变引用类型：通过使用
&mut关键字，可以将不可变引用转换为可变引用。例如：
let mut x = 5; // 可变绑定
let y = &mut x; // 转换为可变引用类型
- 通过模式匹配转换：通过模式匹配可以将变量从一种类型转换为另一种类型。例如：
let x = Some(5); // Option<i32> 类型
if let Some(y) = x {// 将 Option<i32> 类型转换为 i32 类型println!("The value of x is: {}", y);
}
总的来说，Rust 中的 let 变量可以在一定程度上灵活转换为多种类型，但转换的方式取决于具体的场景和需求。
