探索 Rust：变量的可变性，如何保障代码的安全与可维护性

在 Rust 中，变量是用于存储和管理数据的标识符，每个变量都有一个特定的数据类型，例如整数、浮点数、布尔值等。

变量的生命周期由其作用域决定，它们可以在函数内部或全局范围内声明。

Rust 要求在使用变量之前必须对其进行初始化，以确保代码的安全性。

声明和初始化

在 Rust 中，变量的声明和初始化是通过let关键字实现的。声明一个变量后，可以选择初始化它，也可以稍后赋予它一个值。但是使用变量之前必须对其进行初始化，以确保代码的安全性。

在 Rust 中，变量的命名规则很简单：变量名必须以字母或下划线开头，后面可以跟字母、数字或下划线，而且区分大小写，意味着大写字母和小写字母被视为不同的字符。

变量名应该具有描述性，以便你和其他开发者能够清晰地理解变量的用途。

通常，Rust 程序员使用蛇形命名法（snake_case），将多个单词用下划线分隔，例如 my_variable 或 user_age。良好的命名习惯可以提高代码的可读性和可维护性。

声明及初始化

fn main() {
    let username: &str = "lanyulei"; // 声明及初始化
    println!("Hello, {}!", username);
}

先声明后初始化

fn main() {
    let username: &str; // 声明
    username = "lanyulei"; // 初始化
    println!("Hello, {}!", username);
}

类型推导

在 Rust 中，类型推导是允许编译器根据变量的初始值来自动确定变量的数据类型，而无需显式指定。这使得代码更具灵活性和可维护性，同时仍然保持了强类型检查的特性。

例如，当你声明变量并赋予一个整数值时，编译器会自动识别该变量的类型为整数类型（如 i32），而当你赋予一个布尔值时，编译器会将其类型识别为布尔类型（如 bool）。

这种类型推导的机制使得代码更加简洁，减少了不必要的类型注释，同时确保了类型安全。

fn main() {
    let b = true; // Rust 会自动推导 b 的类型为 bool
}

在上面例子中，变量 b 的初始化值为 true，但却并未给变量 b 指定类型，因此 Rust 会自动推导 b 的类型为 bool。

可变性

在 Rust 中，变量的可变性是一项关键概念，它决定了一个变量是否可以在创建后被修改。

默认情况下，Rust中的变量是不可变的，这意味着一旦你为变量赋值，就不能再改变它的值。这种默认不可变性有助于提高代码的安全性，因为它可以防止在不经意之间修改变量的值导致的错误。

但是，如果需要修改变量的值，你可以使用 mut 关键字显式地将变量声明为可变的。

这样，你就可以在需要时修改变量的值，但仍然需要遵循 Rust 的借用规则以确保安全性。可变性的灵活性使得Rust能够在保持代码安全性的同时提供对数据的有效控制，是一项非常强大的特性。

不可变变量示例演示

fn main() {
    let username: &str = "lanyulei"; // 声明及初始化
    username = "lyl"; // 重新赋值
    println!("Hello, {}!", username);
}

在上面的示例中，我们首先定义了一个不可变的变量，并尝试对其进行值的修改操作。

接下来，我们将运行这段代码，以查看会产生什么样的结果。这将帮助我们理解 Rust 中不可变变量的行为。

➜  cargo run
   Compiling hello_world v0.1.0 (/Users/mac/lanyulei/project/rust/hello_world)
warning: value assigned to `username` is never read
 --> src/main.rs:2:9
  |
2 |     let username: &str = "lanyulei"; // 声明及初始化
  |         ^^^^^^^^
  |
  = help: maybe it is overwritten before being read?
  = note: `#[warn(unused_assignments)]` on by default

error[E0384]: cannot assign twice to immutable variable `username`
 --> src/main.rs:3:5
  |
2 |     let username: &str = "lanyulei"; // 声明及初始化
  |         --------
  |         |
  |         first assignment to `username`
  |         help: consider making this binding mutable: `mut username`
3 |     username = "lyl"; // 重新赋值
  |     ^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
warning: `hello_world` (bin "hello_world") generated 1 warning
error: could not compile `hello_world` (bin "hello_world") due to previous error; 1 warning emitted

上面的错误信息明确地告诉我们：“error[E0384]: cannot assign twice to immutable variable username”，也就是说，无法对不可变变量 “username” 进行两次赋值。这个错误提醒我们，Rust 中变量默认是不可变的。

可变变量示例演示

接下来，我们稍微修改一下不可变变量的示例，使其可以重新赋值。

正如之前提到的，要使不可变变量变为可变，我们需要在声明和初始化时使用 mut 关键字来明确指定变量的可变状态，示例如下：

fn main() {
    let mut username: &str = "lanyulei"; // 声明及初始化的时候，加上了 mut 关键字
    println!("Hello, {}!", username);

    username = "lyl"; // 重新赋值
    println!("Hello, {}!", username);
}

让我们运行上述代码，以查看结果如何。

➜ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/hello_world`
Hello, lanyulei!
Hello, lyl!

没有报错，并且正常输出了我们期望的结果。这表明变量 username 已经变成可变了。

隐藏

在 Rust 中，”隐藏”（Shadowing）是一种变量名称的重定义过程，其中在当前作用域中声明了一个与外部作用域中同名的新变量，导致新变量 “隐藏” 了旧变量。这意味着在同一作用域中，如果你重新声明一个已存在的变量名，新变量将隐藏旧变量，但它们实际上是两个不同的变量。

隐藏可以用于创建新的变量，同时保留对旧变量的引用，也可以用于更改变量的类型或值。这种机制允许开发者更灵活地管理变量名称和作用域，但需要注意，过度使用隐藏可能会导致代码可读性下降，因此应谨慎使用。

fn main() {
    let x: i32 = 5; // 定义一个变量 x 并赋值为 5
    println!("x: {}", x); // 输出 x 的值

    let x: &str = "hello"; // 定义一个同名变量 x，覆盖之前的 x，但数据类型是字符串
    println!("x: {}", x); // 输出新的 x 的值

    let x: bool = true; // 定义又一个同名变量 x，覆盖之前的 x，但数据类型是布尔值
    println!("x: {}", x); // 输出新的 x 的值
}

这段代码中，我们在同一作用域内多次定义了同名变量 x，每次定义都会隐藏前一次定义的 x，最终输出的是最后一个 x 的值，但每个 x 的数据类型都不同。这就是 Rust 中的变量隐藏特性。

作用域

Rust 中的变量作用域指的是变量在代码中可访问的范围。在 Rust 中，变量可以在不同的地方定义和使用，但它们的可见性受限于它们所在的代码块（通常由花括号 {} 包围）。

具体来说，当你在一个代码块内定义一个变量，这个变量只能在这个代码块内部被访问和使用，而在代码块之外的地方无法访问。这意味着变量的生命周期被限制在它所在的代码块内，一旦超出了这个范围，变量就会被销毁，释放占用的内存。

这种作用域的概念有助于确保程序的可维护性和安全性，因为它限制了变量的可见性，防止了在不应该访问变量的地方对其进行操作。同时，Rust 还提供了一些特性，如所有权和借用，来更精确地控制变量的生命周期和访问方式，以避免内存安全问题。

简而言之，Rust 的变量作用域定义了变量的可见性范围，确保变量只能在合适的地方使用，以提高代码的可靠性和安全性。

fn main() {
    let x = 42; // 变量 x 的作用域从这里开始
    println!("The value of x is: {}", x);
} // 变量 x 的作用域在这里结束

在这个示例中，x 只在 main 函数内部可见和可访问。如果尝试在其作用域之外访问它，将会导致编译器错误。这有助于确保变量在正确的上下文中使用，并提供了更强的代码安全性。

常量

Rust 中的常量是一种特殊的变量，其值在程序运行期间不能被改变。通常用于存储在整个程序生命周期内都不会变化的值，例如数学常数或配置信息。

在 Rust 中，常量使用 const 关键字声明，并在声明时必须立即赋予一个确定的值，通常用于存储不可变的、在编译时就已知的数据，如数值、字符串或表达式结果等。

它的命名规则要求使用全大写字母和下划线。

同时还需要注意，常量是要求显式指定类型的，不支持类型推导。你必须在声明常量时明确指定其数据类型。这是 Rust 语言的设计决策之一，以增强代码的可读性和可维护性，确保程序员清晰地了解常量的数据类型。

const MY_NAME: &str = "lanyulei"; // 声明一个字符串切片类型的常量 MY_NAME 并赋值为 lanyulei
fn main() {
    println!("常量的值是: {}", MY_NAME);
}

全局变量

在 Rust 中，全局变量通常被称为静态变量（Static Variables）。它们是在程序的整个生命周期内保持不变的变量，存储在固定的内存地址中，可以被任何部分的代码访问。

在 Rust 中，全局变量的声明使用 static 关键字，命名规则通常是全大写，多个单词之间用下划线 _ 分隔，例如 MY_GLOBAL_VARIABLE。

这些变量的值是常量，不可变，必须在声明时立即初始化。

全局变量通常用于存储程序的配置信息、常量值或需要在整个程序中共享的数据。

此外，全局变量和常量一样，都是无法进行类型推导的，因此必须显式的指定类型。

static MY_VERSION: &str = "v0.0.1"; // 声明一个字符串切片类型的全局变量 MY_VERSION 并赋值为 v0.0.1
fn main() {
    println!("全局变量的值是: {}", MY_VERSION);
}

总结

总而言之，Rust 中的变量是用于存储和管理数据的标识符，具有类型、可见性和生命周期。

你可以使用 let 关键字来声明和初始化变量，命名规则采用蛇形命名法，但必须在使用前初始化。

Rust 提供了类型推导，允许编译器自动确定变量的类型，以及可变性控制，使你可以选择是否允许变量的修改。

变量的作用域定义了它们的可见性范围，确保在适当的地方使用变量以提高代码的安全性和可维护性。

此外，Rust 还支持常量和全局变量，用于存储不可变的、整个程序生命周期内都不会变化的数据。

最后，祝愿你在 Rust 的编程旅程中顺风顺水，写出安全可靠的代码！