一、变量声明与初始化

在Rust中，变量默认是不可变的（immutable），但可以通过关键字 mut 将其声明为可变的（mutable）

1. 不可变变量的声明与初始化

不可变变量一旦初始化，其值就无法再被修改

let 变量名: 类型 = 初始值;

fn main() {
    let x: i32 = 10; // 声明并初始化一个不可变变量 x，类型为 i32，值为 10
    println!("x = {}", x); // 输出：x = 10

    // x = 20; // 错误：无法修改不可变变量 x
}

• let 关键字用于声明变量
• x 是一个不可变变量，因此不能修改它的值
• 类型 i32 是整数类型，可以省略（Rust 会自动推断）

2. 可变变量的声明与初始化

可变变量可在程序运行时修改其值

let mut 变量名: 类型 = 初始值;

fn main() {
    let mut y: i32 = 20; // 声明并初始化一个可变变量 y，类型为 i32，值为 20
    println!("y = {}", y); // 输出：y = 20

    y = 30; // 修改可变变量 y 的值
    println!("y = {}", y); // 输出：y = 30
}

• mut 关键字表示变量是可变的
• 可以随时修改可变变量的值

3. 省略类型的变量声明

Rust 支持类型推断，因此可以省略变量的类型声明

let 变量名 = 初始值;

fn main() {
    let z = 42; // 声明并初始化一个不可变变量 z，类型会自动推断为 i32
    println!("z = {}", z); // 输出：z = 42
}

• Rust 会根据初始值自动推断变量的类型
• 如果初始值是整数，则默认推断为 i32

4. 延迟初始化（未初始化的变量）

Rust 可在声明变量时不立即初始化，但使用未初始化的变量会导致编译错误

let 变量名: 类型;

fn main() {
    let w: i32; // 声明一个未初始化的变量 w

    // println!("w = {}", w); // 错误：未初始化的变量 w 不能使用

    w = 50; // 延迟初始化变量 w
    println!("w = {}", w); // 输出：w = 50
}

• 未初始化的变量不能在初始化之前使用
• 延迟初始化通常用于复杂的场景，例如依赖运行时条件的初始化

二、常量声明与初始化

常量是不可变的值，通常用于定义全局不变的数据，常量的生命周期是整个程序运行期间

1. 常量的声明与初始化

const 常量名: 类型 = 值;

fn main() {
    const PI: f64 = 3.14159; // 声明一个常量 PI，类型为 f64，值为 3.14159
    println!("PI = {}", PI); // 输出：PI = 3.14159

    // PI = 3.14; // 错误：无法修改常量的值
}

• const 关键字用于声明常量
• 常量的值必须在编译时确定，因此不能是运行时计算的结果
• 常量的命名通常使用大写字母（如 PI）
• 常量的类型必须显式声明

2. 常量的限制

常量有一些限制：

• 不能使用 mut 关键字修饰
• 不能在运行时动态计算，必须是编译时已知的值
• 常量不能是借用类型（如引用），除非引用的是编译时已知的值

fn main() {
    const MAX_VALUE: i32 = 100; // 合法
    const MESSAGE: &str = "Hello, Rust!"; // 合法

    // const DYNAMIC: i32 = get_value(); // 错误：常量无法调用运行时函数
    // fn get_value() -> i32 { 42 }
}

3. 常量的作用域

常量的作用域可以是全局或局部的

const GLOBAL_CONST: i32 = 1000; // 全局常量

fn main() {
    const LOCAL_CONST: i32 = 2000; // 局部常量

    println!("Global = {}, Local = {}", GLOBAL_CONST, LOCAL_CONST);
    // 输出：Global = 1000, Local = 2000
}

三、变量与常量的对比

四、综合使用示例

fn main() {
    // 变量声明
    let immutable_var: i32 = 10; // 不可变变量
    let mut mutable_var: i32 = 20; // 可变变量
    let inferred_var = 30; // 类型推断
    let uninitialized_var: i32; // 未初始化的变量

    // 常量声明
    const GLOBAL_CONST: i32 = 1000; // 全局常量
    const LOCAL_CONST: i32 = 2000; // 局部常量

    // 使用变量和常量
    println!("immutable_var = {}", immutable_var); // 10
    println!("mutable_var = {}", mutable_var); // 20
    mutable_var = 25; // 可变变量可以修改
    println!("updated mutable_var = {}", mutable_var); // 25

    println!("inferred_var = {}", inferred_var); // 30

    uninitialized_var = 40; // 延迟初始化
    println!("uninitialized_var = {}", uninitialized_var); // 40

    println!("GLOBAL_CONST = {}", GLOBAL_CONST); // 1000
    println!("LOCAL_CONST = {}", LOCAL_CONST); // 2000
}