Rust语言入门第四篇-变量与可变性以及隐藏（Shadowing）

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

    // 使用隐藏创建一个新的变量 y
    let 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 变量声明不同类型的用法：

1. 整数类型示例：

// 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;

2. 浮点数类型示例：

let x: f32 = 3.14;
let y: f64 = 3.14159265359;

3. 布尔类型示例：

let x: bool = true;
let y: bool = false;

4. 字符类型示例：

let x: char = 'a';
let y: char = '😀';

5. 元组类型示例：

let x: (i32, f64, char) = (42, 3.14, 'a');

6. 数组类型示例：

let x: [i32; 5] = [1, 2, 3, 4, 5];

7. 切片类型示例：

let x: &[i32] = &[1, 2, 3, 4, 5];

8. 字符串类型示例：

let x: &str = "Hello, world!";
let y: String = String::from("Hello, world!");

9. 结构体类型示例：

struct Point {
    x: i32,
    y: i32,
}

let p: Point = Point { x: 10, y: 20 };

10. 枚举类型示例：

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

let d: Direction = Direction::Up;

这些示例展示了 let 变量声明不同类型的用法，你可以根据具体的需求选择合适的类型来声明变量。

let 关键字声明的变量类型转换

在 Rust 中，let 关键字用于声明变量。通过 let 关键字声明的变量可以转换为多种类型，具体取决于变量的使用和上下文。下面是一些常见的类型转换：

1. 不可变绑定（Immutable Binding）转换为可变绑定（Mutable Binding）：通过使用 mut 关键字，可以将不可变绑定转换为可变绑定。例如：

let x = 5; // 不可变绑定
let mut y = x; // 转换为可变绑定

2. 从一个类型转换为另一个类型：通过重新赋值或使用类型转换函数，可以将变量从一种类型转换为另一种类型。例如：

let x = 5; // 整数类型
let y = x as f32; // 将整数类型转换为浮点数类型

3. 引用类型转换为可变引用类型：通过使用 &mut 关键字，可以将不可变引用转换为可变引用。例如：

let mut x = 5; // 可变绑定
let y = &mut x; // 转换为可变引用类型

4. 通过模式匹配转换：通过模式匹配可以将变量从一种类型转换为另一种类型。例如：

let x = Some(5); // Option<i32> 类型
if let Some(y) = x {
    // 将 Option<i32> 类型转换为 i32 类型
    println!("The value of x is: {}", y);
}

总的来说，Rust 中的 let 变量可以在一定程度上灵活转换为多种类型，但转换的方式取决于具体的场景和需求。