变量和可变性

ch03-01-variables-and-mutability.md

commit 54164e99f7a1ad27fc6fc578783994513abd988d

正如第二章中“使用变量储存值” 部分提到的那样，变量默认是不可改变的（immutable）。这是 Rust 提供给你的众多优势之一，让你得以充分利用 Rust 提供的安全性和简单并发性来编写代码。不过，你仍然可以使用可变变量。让我们探讨一下 Rust 为何及如何鼓励你利用不可变性，以及何时你会选择不使用不可变性。

当变量不可变时，一旦值被绑定一个名称上，你就不能改变这个值。为了对此进行说明，使用 cargo new variables 命令在 projects 目录生成一个叫做 variables 的新项目。

接着，在新建的 variables 目录，打开 src/main.rs 并将代码替换为如下代码，这些代码还不能编译，我们会首次检查到不可变错误（immutability error）。

文件名: src/main.rs

  1. fn main() {
  2.     let x = 5;
  3.     println!("The value of x is: {x}");
  4.     x = 6;
  5.     println!("The value of x is: {x}");
  6. }

保存并使用 cargo run 运行程序。应该会看到一条错误信息，如下输出所示：

  1. $ cargo run
  2.    Compiling variables v0.1.0 (file:///projects/variables)
  3. error[E0384]: cannot assign twice to immutable variable `x`
  4.  --> src/main.rs:4:5
  5.   |
  6. 2 |     let x = 5;
  7.   |         -
  8.   |         |
  9.   |         first assignment to `x`
  10.   |         help: consider making this binding mutable: `mut x`
  11. 3 |     println!("The value of x is: {x}");
  12. 4 |     x = 6;
  13.   |     ^^^^^ cannot assign twice to immutable variable
  15. For more information about this error, try `rustc --explain E0384`.
  16. error: could not compile `variables` due to previous error

这个例子展示了编译器如何帮助你找出程序中的错误。虽然编译错误令人沮丧，但那只是表示程序不能安全的完成你想让它完成的工作；并 不能 说明你不是一个好程序员！经验丰富的 Rustacean 们一样会遇到编译错误。

错误信息指出错误的原因是 不能对不可变变量 x 二次赋值（cannot assign twice to immutable variable x ），因为你尝试对不可变变量 x 赋第二个值。

在尝试改变预设为不可变的值时，产生编译时错误是很重要的，因为这种情况可能导致 bug。如果一部分代码假设一个值永远也不会改变，而另一部分代码改变了这个值，第一部分代码就有可能以不可预料的方式运行。不得不承认这种 bug 的起因难以跟踪，尤其是第二部分代码只是 有时 会改变值。

Rust 编译器保证，如果声明一个值不会变，它就真的不会变，所以你不必自己跟踪它。这意味着你的代码更易于推导。

不过可变性也是非常有用的，可以用来更方便地编写代码。尽管变量默认是不可变的，你仍然可以在变量名前添加 mut 来使其可变，正如在第二章所做的那样。mut 也向读者表明了其他代码将会改变这个变量值的意图。

例如，让我们将 src/main.rs 修改为如下代码：

文件名: src/main.rs

  1. fn main() {
  2.     let mut x = 5;
  3.     println!("The value of x is: {x}");
  4.     x = 6;
  5.     println!("The value of x is: {x}");
  6. }

现在运行这个程序，出现如下内容：

  1. $ cargo run
  2.    Compiling variables v0.1.0 (file:///projects/variables)
  3.     Finished dev [unoptimized + debuginfo] target(s) in 0.30s
  4.      Running `target/debug/variables`
  5. The value of x is: 5
  6. The value of x is: 6

通过 mut，允许把绑定到 x 的值从 5 改成 6。是否让变量可变的最终决定权仍然在你，取决于在某个特定情况下，你是否认为变量可变会让代码更加清晰明了。

常量

类似于不可变变量，常量(constants) 是绑定到一个名称的不允许改变的值，不过常量与变量还是有一些区别。

首先，不允许对常量使用 mut。常量不光默认不能变，它总是不能变。

声明常量使用 const 关键字而不是 let，并且 必须 注明值的类型。在下一部分，“数据类型” 中会介绍类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。

常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。

最后一个区别是，常量只能被设置为常量表达式，而不可以是其他任何只能在运行时计算出的值。

下面是一个声明常量的例子：

  1. #![allow(unused)]
  2. fn main() {
  3. const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
  4. }

常量的名称是 THREE_HOURS_IN_SECONDS，它的值被设置为 60（一分钟内的秒数）乘以 60（一小时内的分钟数）再乘以 3（我们在这个程序中要计算的小时数）的结果。Rust 对常量的命名约定是在单词之间使用全大写加下划线。编译器能够在编译时计算一组有限的操作，这使我们可以选择以更容易理解和验证的方式写出此值，而不是将此常量设置为值10,800。有关声明常量时可以使用哪些操作的详细信息，请参阅 Rust Reference 的常量求值部分。

在声明它的作用域之中，常量在整个程序生命周期中都有效，此属性使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。

将遍布于应用程序中的硬编码值声明为常量，能帮助后来的代码维护人员了解值的意图。如果将来需要修改硬编码值，也只需修改汇聚于一处的硬编码值。

隐藏

正如在第二章猜数字游戏中所讲，我们可以定义一个与之前变量同名的新变量。Rustacean 们称之为第一个变量被第二个 隐藏（Shadowing） 了，这意味着当您使用变量的名称时，编译器将看到第二个变量。实际上，第二个变量“遮蔽”了第一个变量，此时任何使用该变量名的行为中都会视为是在使用第二个变量，直到第二个变量自己也被隐藏或第二个变量的作用域结束。可以用相同变量名称来隐藏一个变量，以及重复使用 let 关键字来多次隐藏，如下所示：

文件名: src/main.rs

  1. fn main() {
  2.     let x = 5;
  4.     let x = x + 1;
  6.     {
  7.         let x = x * 2;
  8.         println!("The value of x in the inner scope is: {x}");
  9.     }
  11.     println!("The value of x is: {x}");
  12. }

这个程序首先将 x 绑定到值 5 上。接着通过 let x = 创建了一个新变量 x，获取初始值并加 1，这样 x 的值就变成 6 了。然后，在使用花括号创建的内部作用域内，第三个 let 语句也隐藏了 x 并创建了一个新的变量，将之前的值乘以 2，x 得到的值是 12。当该作用域结束时，内部 shadowing 的作用域也结束了，x 又返回到 6。运行这个程序，它会有如下输出：

  1. $ cargo run
  2.    Compiling variables v0.1.0 (file:///projects/variables)
  3.     Finished dev [unoptimized + debuginfo] target(s) in 0.31s
  4.      Running `target/debug/variables`
  5. The value of x in the inner scope is: 12
  6. The value of x is: 6

隐藏与将变量标记为 mut 是有区别的。当不小心尝试对变量重新赋值时，如果没有使用 let 关键字，就会导致编译时错误。通过使用 let，我们可以用这个值进行一些计算，不过计算完之后变量仍然是不可变的。

mut 与隐藏的另一个区别是，当再次使用 let 时，实际上创建了一个新变量，我们可以改变值的类型，并且复用这个名字。例如，假设程序请求用户输入空格字符来说明希望在文本之间显示多少个空格，接下来我们想将输入存储成数字（多少个空格）：

  1. fn main() {
  2.     let spaces = "   ";
  3.     let spaces = spaces.len();
  4. }

第一个 spaces 变量是字符串类型，第二个 spaces 变量是数字类型。隐藏使我们不必使用不同的名字，如 spaces_str 和 spaces_num；相反，我们可以复用 spaces 这个更简单的名字。然而，如果尝试使用 mut，将会得到一个编译时错误，如下所示：

  1. fn main() {
  2.     let mut spaces = "   ";
  3.     spaces = spaces.len();
  4. }

这个错误说明，我们不能改变变量的类型：

  1. $ cargo run
  2.    Compiling variables v0.1.0 (file:///projects/variables)
  3. error[E0308]: mismatched types
  4.  --> src/main.rs:3:14
  5.   |
  6. 2 |     let mut spaces = "   ";
  7.   |                      ----- expected due to this value
  8. 3 |     spaces = spaces.len();
  9.   |              ^^^^^^^^^^^^ expected `&str`, found `usize`
  11. For more information about this error, try `rustc --explain E0308`.
  12. error: could not compile `variables` due to previous error

现在我们已经了解了变量如何工作，让我们看看变量可以拥有的更多数据类型。