变量与注释

> 学习 Rust 的变量声明语法，以及单行注释、块注释与文档注释的适用场景。

变量与赋值

let 绑定

概念名称： let 用于声明变量绑定，Rust 默认变量不可变。

语法结构：
┌──────────────────────────────────────┐
│  let [mut] 变量名: 类型 = 值;         │
│   ↑   ↑      ↑      ↑       ↑        │
│   关键字 可选   名字   可选   初始值  │
│         可变         类型            │
│         标记         标注            │
│                                       │
│  let x = 5;         → 不可变，类型推断 │
│  let mut x = 5;     → 可变，类型推断  │
│  let x: i32 = 5;    → 不可变，显式类型 │
└──────────────────────────────────────┘

为什么用它？

// 没有 let：变量随意创建，容易拼写错误
x = 5;  // 是赋值还是新建？不清楚

// 有 let：明确声明新变量，编译器检查
let x = 5;  // 明确声明新变量
let x = 6;  // ❌ 编译错误：不能重新赋值
let mut y = 5;  // 显式声明可变
y = 6;  // ✅ 允许修改

▶ Run

最简示例

fn main() {
    let x = 5;  // 不可变变量
    println!("x = {}", x);
}

▶ Run

详细示例

fn main() {
    // 声明并初始化变量
    let x = 5;
    println!("x = {}", x);

    // 变量名必须是蛇形命名（snake_case）
    let my_variable = 10;
    let another_one = 20;
    println!("my_variable = {}, another_one = {}", my_variable, another_one);

    // 变量一旦赋值，默认不可变
    let y = 100;
    // y = 200;  // ❌ 错误！不能重新赋值

    // 使用 mut 声明可变变量
    let mut z = 300;
    z = 400;  // ✅ 正确
    println!("z = {}", z);
}

▶ Run

关键代码说明：

代码	含义	为什么这样写
let x = 5	声明不可变变量	Rust 默认不可变，更安全
let mut z = 300	声明可变变量	mut 显式标记可修改
my_variable	蛇形命名	Rust 命名约定，提高可读性

---

变量类型推断

概念名称： Rust 编译器自动推断变量类型，减少冗余标注。

语法结构：
┌──────────────────────────────────────┐
│  let 变量 = 值;          → 推断类型   │
│  let 变量: 类型 = 值;    → 显式标注   │
│                                       │
│  let x = 42;    → 推断为 i32         │
│  let y = 3.14;  → 推断为 f64         │
│  let x: i64 = 42; → 显式指定 i64     │
└──────────────────────────────────────┘

最简示例

fn main() {
    let x = 42;           // 推断为 i32
    let y = 3.14;         // 推断为 f64
}

▶ Run

详细示例

fn main() {
    // Rust 可以推断类型
    let x = 42;           // 推断为 i32
    let y = 3.14;         // 推断为 f64
    let s = "hello";      // 推断为 &str
    let b = true;         // 推断为 bool

    println!("x={} (i32), y={} (f64), s={} (&str), b={} (bool)", x, y, s, b);

    // 显式标注类型
    let a: i32 = 42;
    let b: f64 = 3.14;
    let c: bool = true;

    // 何时需要显式标注？
    // 1. 编译器无法推断时
    // 2. 需要特定类型时
    let num = 42;         // i32（默认）
    let big: i64 = 42;    // 显式指定 i64
    
    println!("a={}, b={}, c={}, num={}, big={}", a, b, c, num, big);
}

▶ Run

关键代码说明：

代码	含义	为什么这样写
let x = 42	类型推断为 i32	i32 是 Rust 默认整数类型
let y = 3.14	类型推断为 f64	f64 是 Rust 默认浮点类型
let big: i64 = 42	显式指定类型	需要更大范围或 API 要求

---

常量与静态变量

概念名称： const 是编译时常量，static 是全局静态变量。

语法结构：
┌──────────────────────────────────────┐
│  const 名称: 类型 = 值;              │
│  static 名称: 类型 = 值;             │
│                                       │
│  const MAX: u32 = 100;  → 编译时常数  │
│  static LANG: &str = "Rust"; → 静态  │
└──────────────────────────────────────┘

最简示例

const MAX_POINTS: u32 = 100_000;

fn main() {
    println!("Max: {}", MAX_POINTS);
}

▶ Run

详细示例

// 常量（必须标注类型）
const MAX_POINTS: u32 = 100_000;
const PI: f64 = std::f64::consts::PI;

// 静态变量（整个程序生命周期）
static LANGUAGE: &str = "Rust";

fn main() {
    println!("Max points: {}", MAX_POINTS);
    println!("PI: {}", PI);
    println!("Language: {}", LANGUAGE);
}

▶ Run

关键代码说明：

代码	含义	为什么这样写
const MAX_POINTS: u32	编译时常量	必须标注类型，值在编译时内联
100_000	数字分隔符	提高可读性，等价于 100000
static LANGUAGE	静态变量	全局唯一实例，整个程序生命周期

---

变量遮蔽（Shadowing）

概念名称： 用 let 重新声明同名变量，遮蔽旧值，可改变类型。

语法结构：
┌──────────────────────────────────────┐
│  let x = 值1;                         │
│  let x = 值2;  // 遮蔽旧的 x          │
│                                       │
│  let x = 5;     → x 是 i32           │
│  let x = "hi";  → 新 x 是 &str       │
└──────────────────────────────────────┘

为什么用它？

// 没有：需要不同变量名，代码冗余
let x = 5;
let x_transformed = x + 1;
let x_final = x_transformed * 2;

// 有：复用变量名，表达转换过程
let x = 5;
let x = x + 1;    // 新 x 遮蔽旧 x
let x = x * 2;    // 再次遮蔽
println!("x = {}", x);  // 12

▶ Run

最简示例

fn main() {
    let x = 5;
    let x = x + 1;
    println!("x = {}", x);  // 6
}

▶ Run

详细示例

fn main() {
    // 遮蔽允许重新使用变量名
    let x = 5;
    let x = x + 1;      // 新的 x 遮蔽了旧的 x
    let x = x * 2;

    println!("x = {}", x);  // 12

    // 遮蔽可以改变类型
    let spaces = "   ";     // &str 类型
    let spaces = spaces.len();  // usize 类型

    println!("spaces = {}", spaces);  // 3

    // 遮蔽 vs mut
    // mut: 修改值，类型不变
    let mut count = 0;
    count += 1;

    // shadowing: 新值，可以改类型
    let count = "done";
    println!("count = {}", count);
}

▶ Run

关键代码说明：

代码	含义	为什么这样写
let x = x + 1	遮蔽旧值	新 x 是独立变量，旧 x 失效
spaces.len()	类型转换	遮蔽允许从 &str 变为 usize
let mut count	可变变量	只能修改值，不能改类型

---

注释

概念名称： Rust 支持单行注释 //、多行注释 /* */ 和文档注释 ///。

语法结构：
┌──────────────────────────────────────┐
│  // 单行注释                         │
│  /* 多行注释 */                      │
│  /// 文档注释（生成 API 文档）        │
│  //! 模块级文档注释                   │
└──────────────────────────────────────┘

最简示例

fn main() {
    // 单行注释
    let x = 5;  // 行尾注释
    println!("x = {}", x);
}

▶ Run

详细示例

fn main() {
    // 单行注释：两个斜杠

    /*
       多行注释
       可以跨越多行
    */

    // 文档注释（生成 API 文档）
    /// 这是函数的文档注释
    /// 支持 Markdown 格式
    ///
    /// # Examples
    ///
    /// ```
    /// let result = add(2, 3);
    /// assert_eq!(result, 5);
    /// ```
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    //! 模块级文档注释
    // 通常放在文件开头
    
    println!("注释示例完成");
}

▶ Run

关键代码说明：

代码	含义	为什么这样写
//	单行注释	最常见，编译器忽略
/* */	多行注释	可嵌套，适合大段说明
///	文档注释	用于 cargo doc 生成 API 文档
//!	模块级注释	放在文件开头，描述整个模块

---

小结

• let 声明变量，默认不可变；let mut 可变
• // 单行注释，/* */ 块注释
• /// 文档注释用于函数、结构体等顶层条目，不用于局部变量
• 变量名使用 snake_case 风格

练习题

详见：练习题