let 变量绑定 ​

什么是变量绑定 ​

在 Rust 中,声明一个变量用的是 let 关键字。Rust 把这个过程叫做"绑定"而不是"赋值",这个叫法强调的是"把一个值和一个名字绑在一起"。这背后涉及 Rust 的所有权系统——当你写 let x = 5; 的时候,变量 x 就成了值 5 的所有者。

用 let 声明出来的变量,默认是不可变的(immutable)。一旦绑定了值,就不能再改它。这是 Rust 的核心设计理念:如果你不打算改变一个值,编译器就帮你锁死,避免后续出现意外修改。

rust
fn main() {
    // 使用 let 关键字声明变量 x,并绑定值 5
    // 编译器自动推断 x 的类型为 i32(整数的默认类型)
    let x = 5;

    // 打印 x 的值,{} 是占位符
    println!("x 的值是:{}", x);

    // 下面这行如果取消注释会编译报错:
    // cannot assign twice to immutable variable
    // 因为 x 默认是不可变的
    // x = 10;
}

带类型标注的绑定 ​

Rust 编译器大多数时候能自动推断出变量类型,但有时你需要手动标注。比如你想让一个数字是 u8 而不是默认的 i32,或者调用 parse() 方法时编译器不知道该转成什么类型。

rust
fn main() {
    // 显式标注类型为 u32(无符号 32 位整数)
    let age: u32 = 25;

    // 显式标注类型为 f64(64 位浮点数)
    let pi: f64 = 3.14159;

    // 显式标注类型为 bool
    let is_active: bool = true;

    // 显式标注类型为 char(单个 Unicode 字符)
    let initial: char = 'R';

    // 从字符串解析数字时,必须标注目标类型
    // 因为 parse() 可以返回很多种数字类型,编译器无法自动推断
    let guess: u32 = "42".parse().expect("不是数字");

    println!("年龄:{},圆周率:{},激活:{},首字母:{},猜测:{}",
        age, pi, is_active, initial, guess);
}

类型标注的语法是变量名后加冒号和类型名:let 变量名: 类型 = 值;

通过表达式绑定 ​

let 右边不一定是一个简单的字面量,可以是任何表达式——函数调用、代码块、运算等。

rust
fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // 绑定函数调用的返回值
    let sum = add(3, 7);

    // 绑定代码块的值
    // 代码块最后一个表达式(没有分号)就是这个块的值
    let result = {
        let x = 10;
        let y = 20;
        x + y  // 没有分号,这是一个表达式,值为 30
    };

    // 绑定运算结果
    let doubled = sum * 2;

    // 绑定方法调用的返回值
    let greeting = String::from("hello");
    let length = greeting.len();

    println!("sum={}, result={}, doubled={}, length={}", sum, result, doubled, length);
}

多变量解构绑定 ​

let 配合模式匹配可以同时绑定多个值:

rust
fn main() {
    // 元组解构:同时绑定三个变量
    let (a, b, c) = (1, 2.5, "hello");
    println!("a={}, b={}, c={}", a, b, c);

    // 用下划线 _ 忽略不需要的值
    let (x, _, z) = (10, 20, 30);
    println!("x={}, z={}", x, z);

    // 嵌套解构
    let ((first, second), third) = ((1, 2), 3);
    println!("first={}, second={}, third={}", first, second, third);
}

未初始化的变量 ​

Rust 允许先声明变量后初始化,但使用前必须初始化:

rust
fn main() {
    // 声明但不初始化(必须标注类型)
    let x: i32;

    // 在使用之前初始化
    x = 42;

    // 现在可以使用了
    println!("x = {}", x);

    // 如果在初始化之前就使用,编译器会报错:
    // error[E0381]: used binding `x` isn't initialized
}

基本示例 ​

rust
fn main() {
    // 场景一:接收用户输入后绑定
    let input = "2026";
    let year: u32 = input.parse().expect("解析失败");
    println!("年份:{}", year);

    // 场景二:条件表达式绑定
    let score = 85;
    let grade = if score >= 90 {
        "优秀"
    } else if score >= 60 {
        "及格"
    } else {
        "不及格"
    };
    println!("成绩等级:{}", grade);

    // 场景三:循环中的绑定
    for i in 0..5 {
        // 每次循环 i 都是一个新的绑定
        let squared = i * i;
        println!("{} 的平方是 {}", i, squared);
    }

    // 场景四:match 表达式绑定
    let number = 7;
    let description = match number {
        1 => "一",
        2..=5 => "二到五之间",
        _ => "其他",
    };
    println!("{} 是 {}", number, description);
}

常见问题 ​

问题一:为什么默认不可变?其他语言都是可变的啊。

Rust 的理念是"需要可变时显式声明",而不是"不需要可变时显式声明"。实际代码中大多数变量只赋值一次,强制不可变能帮编译器更好地优化代码,也能防止你在某个角落不小心改了不该改的值。

问题二:let 和其他语言变量声明的对比。

特性Rust letJavaScript letPython 赋值C int x
默认可变性不可变可变可变可变
类型系统静态类型 + 推断动态类型动态类型静态类型,需声明
所有权语义有无无无
作用域块级块级函数级块级
未初始化使用编译期阻止返回 undefined报错未定义行为

问题三:let 声明时不初始化可以吗?

可以,但需要标注类型,且必须在使用之前初始化。Rust 在编译期会追踪每条代码路径,确保变量在任何可能的执行路径上都已经被初始化。

问题四:同名变量重复声明会怎样?

Rust 中叫"变量遮蔽"(Shadowing),是合法操作。新的 let 会创建一个全新变量,和原来的无关。详见"变量遮蔽 Shadowing"章节。

适用场景 ​

  • 函数内局部变量声明:几乎所有局部变量都通过 let 声明
  • 接收函数返回值:let result = some_function();
  • 解构赋值:从元组、结构体中提取字段
  • 接收迭代器的值:for 循环中的循环变量本质上也是 let 绑定
  • 模式匹配中的值绑定:if let、while let、match 中绑定匹配到的值

注意事项 ​

  • let 声明的变量默认不可变,需要修改值时加 mut 关键字
  • 类型推断在大多数场景下工作良好,但 parse()、空集合等情况需要手动标注
  • 变量作用域从声明处开始,到所在代码块的右花括号结束
  • 未初始化的变量不能使用,编译器会在编译期强制检查
  • 变量命名用 snake_case 风格,比如 user_name、item_count
  • 以下划线开头的变量名(如 _unused)不会触发"未使用变量"警告

总结 ​

let 是 Rust 中声明局部变量的关键字,它的核心语义是"绑定"——把一个值和一个名字绑在一起,默认这个绑定是不可变的。这个设计让编译器能在编译期帮你检查意外的值修改和未初始化使用等问题。let 支持类型推断也支持显式标注,支持简单绑定也支持模式解构。理解 let 的不可变默认是学习 Rust 的起点,后续的 mut、变量遮蔽、所有权等概念都建立在这个基础上。