1.变量
在 Rust 中，类型安全是通过静态类型系统来实现的。变量绑定默认情况下是不可变的（immutable）。
在 Rust 中声明一个变量时，默认情况下它是不可变的。例如：
fn main() {
let x ：i32 = 5; // 这是一个不可变绑定，默认情况下不可改变其值
// x = 10; // 这将导致编译错误，因为 x 是不可变的
}
在上面例子中，x 被声明为一个不可变绑定，并初始化为 5。如果试图修改 x 的值（例如尝试将 x 的值改变为 10），将会导致编译错误，因为变量默认情况下是不可变的。
为了允许变量可变，可以使用 mut 关键字来显式地声明一个可变的绑定：
fn main() {
let mut y = 5; // 使用 mut 关键字声明可变绑定
y = 10; // 这是合法的，因为 y 是可变的
println!("The value of y is: {}", y); // 输出 y 的值
}
使用了 mut 关键字来声明一个可变的绑定 y，然后成功将 y 的值修改为 10。
2.类型推断
在 Rust 中，编译器会根据变量的使用方式来推断变量的类型。
fn main() {
let x = 5; // 编译器根据赋值来推断 x 的类型为 i32
let y = 3.14; // 编译器根据赋值来推断 y 的类型为 f64
let sum = x + y; // 编译器根据 x 和 y 的使用来推断 sum 的类型
println!("The sum is: {}", sum); // 输出 sum 的值
}
编译器根据赋值来推断 x 的类型为 i32，y 的类型为 f64。然后，当 x 和 y 作为操作数相加时，编译器会根据其使用来推断 sum 的类型。在这种情况下，sum 的类型会被推断为 f64，因为它是 i32 和 f64 类型的混合运算结果。Rust 的类型推断功能允许编写更加简洁且灵活的代码，但也保持了类型安全。
值得注意的是，Rust 编译器可以根据变量声明和用法的约束来推断类型。像这样声明的变量并不是某种动态的“任意类型”，可以容纳任何数据。这种声明所生成的机器代码与显式声明类型的代码完全相同。只是编译器完成了这个转换。
下面的代码告诉编译器将某种泛型容器中的内容进行复制，而代码本身并没有显式地指定包含的类型，而是使用 _ 作为占位符：
fn main() {
let mut container = Vec::new(); // Rust 根据使用推断出 container 的类型为 Vec<_>
container.push(5); // 向向量中添加一个 i32 类型的元素
container.push(3.14); // 向向量中添加一个 f64 类型的元素
for element in container {
println!("Element: {}", element);
}
}
container 被初始化为一个空的向量 Vec<_>。下划线 _ 是一个占位符，告诉编译器根据插入向量的元素推断类型。在这种情况下，container 是一个可以容纳不同类型元素的向量（根据插入的元素类型推断出 i32 和 f64）。
Rust 根据容器的使用推断出其类型，并允许其容纳不同类型的元素。但是，一旦推断出特定类型，容器的类型就固定了，除非另有规定，否则不会接受不同类型的元素。
3. 静态变量
静态变量在整个程序执行期间都会存在，并且不会发生移动（move）。
在 Rust 中，静态变量（static variables）拥有 'static 生命周期，它们在程序启动时被初始化，并且在整个程序的生命周期内保持不变。这些变量存储在程序的静态存储区域中，因此它们不会被销毁或移动。这意味着静态变量的生存周期与整个程序的生命周期相同。
由于静态变量的生命周期是 'static，因此其持续时间长达整个程序的运行期间，所以它们不会被移动。在 Rust 中，静态变量的引用可以安全地传递并在整个程序中使用，因为它们的生命周期不会结束或改变。
static BANNER: &str = "Welcome to RustOS 3.14";
fn main() {
println!("{BANNER}");
}
静态变量在使用时并不会被内联，并且具有实际关联的内存位置。这对于不安全编程和嵌入式代码非常有用，并且这些变量在整个程序执行期间都存在。当全局范围的值不需要对象标识时，通常更倾向于使用 const。
由于静态变量可以从任何线程访问，因此它们必须是 Sync 的。可以通过 Mutex、atomic 或类似的方式实现内部可变性（interior mutability）。也可以有可变的静态变量，但它们需要手动进行同步，因此对它们的任何访问都需要使用不安全的代码。我们将在关于不安全 Rust 的章节中探讨可变的静态变量。
4.常量（const）
常量在编译时被求值，它们的值会在使用的地方被内联。
在 Rust 中声明一个常量时，编译器会在编译期间计算常量的值，并且将该值内联到代码中使用该常量的地方。这意味着编译器会将常量的实际值直接替换到代码中，而不是在运行时进行计算。这种内联有助于提高代码的效率，并且保证了常量在运行时是不可变的。
例如：
const VALUE: i32 = 42;
fn main() {
let x = VALUE * 2; // 编译器会将 VALUE * 2 替换为 42 * 2，这个值会在编译期间被计算
println!("The value of x is: {}", x);
}
VALUE * 2 的计算结果会在编译时被替换为 84，并且这个值会在运行时被直接使用。这种行为确保了常量在编译期间被求值，并且在编译生成的机器代码中直接被替换。
- 常量（使用
const声明）在使用时会被内联，其值会直接替换到代码中。 - 标记为
const的函数可以在编译时调用以生成常量值。尽管这些函数可以在运行时被调用，但其主要目的是在编译期间进行计算，生成常量值。
5.变量作用域与隐藏变量
在 Rust 中，可以使用作用域隐藏来重新定义同名变量，无论是来自外部作用域还是同一作用域的变量。
fn main() {
let a = 5; // 创建变量 a
{
let a = "hello"; // 在新作用域中重新定义了同名变量 a，隐藏了外部作用域中的 a
println!("Inner scope: {}", a); // 输出新作用域中的 a，值为 "hello"
} // 这里的 a 超出了内部作用域的范围
println!("Outer scope: {}", a); // 输出外部作用域中的 a，值为 5，因为内部作用域中的 a 不再可见
}
内部作用域中重新定义的 a 变量隐藏了外部作用域中的同名变量 a。在内部作用域中重新定义的 a 只在该作用域内可见，超出该作用域后，再次访问 a 时会得到外部作用域中的值。这种方式允许你在同一作用域中使用相同名称的变量进行重新定义，而不会产生冲突。
在 Rust 中，变量隐藏与变量的可变性是两种不同的概念。通过变量隐藏，重新定义的同名变量在同一作用域内会覆盖之前定义的变量，但它们的内存位置会同时存在，且都可以使用相同的名称，具体取决于代码中的位置。
变量隐藏允许重新定义具有相同名称的变量，并且新定义的变量可以拥有不同的类型。一开始，变量隐藏可能看起来有些晦涩，但它对于在 .unwrap() 之后保留值非常方便。
以下代码演示了为什么编译器不能简单地在重新定义一个作用域内的不可变变量时重用内存位置，即使类型没有发生变化。
fn main() {
let x: i32 = 5;
println!("Original x: {}", x);
{
let x: i32 = 10; // 在新的作用域内重新定义了同名变量 x，类型仍为 i32
println!("Inner x: {}", x); // 输出内部作用域的 x，值为 10
} // 这里的 x 超出了内部作用域的范围
println!("Outer x: {}", x); // 输出外部作用域的 x，值为 5，因为内部作用域中的 x 不再可见
let x: &str = "hello"; // 在同一作用域内，将 x 重新定义为字符串类型
println!("New x: {}", x); // 输出重新定义的 x，值为 "hello"
}
在上面例子中，重新定义的 x 变量在内部作用域中隐藏了外部作用域中的同名变量 x，但它们的内存位置并不相同。即使类型没有发生变化，重新定义的 x 仍然会分配新的内存空间。这说明了变量隐藏与可变性不同，虽然它们都涉及变量值的改变，但是变量隐藏会重新分配内存，而不是简单地改变值。