文章

一切从 let 开始:语言基础与常用概念

0x01 变量与可变性

上一篇把环境搭好了, main.rs 里最后留了一行 let greeting = "hello, Rust!!!"。 let 关键字值得单独拿出来讲,它是 Rust 语法里最不起眼、却最能体现这门语言性格的地方:变量默认不可变、类型在编译期确定、代码块和 if 本身都是表达式。这一篇就从它说起。

let 干的事很简单,给一个值绑定一个名字。但它有一个多数语言没有的默认设定:变量默认不可变。

默认不可变

在 Java 里,想让变量不可改,得额外加上 final 关键字;Go 没有不可变变量的概念;Python 则完全依赖约定。可变是常态,不可变才需要额外声明。Rust 把这条默认规则反过来了:

fn main() {
    let x = 5;
    println!("x = {x}");

    // 下面这行会报 E0384:cannot assign twice to immutable variable
    // x = 6;

    let mut y = 10;
    y = 11; // 加了 mut 才能改
    println!("y = {y}");
}

第一次写 Rust 时我就觉得别扭,不就是个变量,改一下还要额外声明?后来才想明白了,编译器要替你把内存和并发的帐算清楚,前提是它得知道哪些值会在什么时候变。一个“可变的变量”意味着它的值可能在任何时间、任何地点被修改,这会让编译器失去确定性,也让读代码的人失去确定性。所以 Rust 选择让“可变”成为一件需要显式声明、并且有成本的事。

代价当然有:你会多写不少 mut。但换来的是,读代码时哪里会变是一眼可见的信息,不必把整段代码读完、反复推敲逻辑才敢下结论。

可变与常量

Rust 里还有一类值叫常量,用 const 声明。它和 let 容易混淆,但差别不小:const 永远不可变,不能对常量使用 mut;编译器不会自动推断常量的类型,必须显式标注;可以定义在函数外,而 let 只能在函数体或代码块内使用;值还必须在**编译期 **就能确定。

const PI: f64 = 3.1415926;

命名习惯用全大写下划线分隔。什么时候该用 const?当这个值是配置性的、全程序共享、且永不改变时,比如光速、数学常数。

遮蔽

最后一个容易混淆的概念是遮蔽(shadowing):用 let 再次声明一个同名变量,将之前的变量隐藏。

fn main() {
    let data = "123";        // &str
    let data = data.len();   // usize,类型都换了
    println!("{data}");

    let x = 5;
    {
        let x = x * 10;            // 内层遮蔽
        println!("inner x = {x}"); // 50
    }
    println!("outer x = {x}");     // 5
}

注意两点。第一,遮蔽可以改变类型,data 从 &str 变成了 usize,这是 mut 做不到的。第二,旧变量没有被销毁,只是暂时不可见;内层的 let x = x * 10 用的是外层的 5,出了内层作用域后,外层的 5 又恢复可见。

不能把遮蔽和 mut 混为一谈,两者解决的是完全不同的问题:

let mut let 遮蔽
本质 改同一个变量的值 新建一个同名变量
能否换类型 不能 能
旧值 被覆盖 被藏起来,作用域结束后可能重现

0x02 数据类型

Rust 是静态类型语言,每个变量的类型在编译期必须确定。但日常编码中几乎感知不到这一点,因为类型推导能力很强—— let x = 5 不需要标注类型。只有推导不出来时,编译器才会要求你补上:

fn main() {
    let guess: u32 = "42".parse().expect("不是数字");
    //  ^^^^^^  这里编译器需要你补上guess的类型
    println!("{guess}");
}

: u32 不是多余的装饰,而是在告诉 parse 应该解析成哪种整数。

标量类型

标量表示单个值。Rust 有四类:整数、浮点数、布尔值和字符。

整数按位宽划分:i 表示有符号,u 表示无符号;isize 和 usize 则随平台取 32 或 64 位。

位宽 有符号 无符号
8 位 i8 u8
16 位 i16 u16
32 位 i32 u32
64 位 i64 u64
128 位 i128 u128
平台相关 isize usize

整数默认 i32;集合下标、长度通常用 usize。

整数支持多种进制,下划线用于分隔提高可读性,字面量也可加类型后缀:

fn main() {
    let decimal = 98_222;
    let hex = 0xff;
    let octal = 0o77;
    let binary = 0b1111_0000;
    let byte: u8 = b'A';
    let small = 57u8;
    println!("{decimal} {hex} {octal} {binary} {byte} {small}");
}

整数溢出也需要注意: u8 最大值为 255,debug 构建中溢出会触发 panic; release 构建默认按补码回绕(256 变为 0),但不应依赖这种隐式行为。如果需要明确的溢出行为,可以使用标准库提供的方法:

fn main() {
    let x: u8 = 255;
    println!("{}", x.wrapping_add(1));   // 0:明确回绕
    println!("{:?}", x.checked_add(1));  // None:溢出时报告无结果
    println!("{:?}", x.overflowing_add(1)); // (0, true):结果和溢出标志
    println!("{}", x.saturating_add(1)); // 255:停在上限
}

浮点类型是 f32 和 f64,默认推断为 f64,在现代 CPU 上两者速度相近,但 f64 精度更高;二者均遵循 IEEE 754 标准。数值运算包括加减乘除和取余;整数除法向零截断,5 / 2 结果为 2。

fn main() {
    let pi = 3.14; // f64
    let small: f32 = 3.0;
    let quotient = 5 / 2;
    let remainder = 5 % 2;
    println!("{pi} {small} {quotient} {remainder}");
}

布尔类型只有 true 和 false 两个值,占一字节,常用于条件判断。 字符类型用单引号、占 4 字节,表示 Unicode 标量值,中文和 emoji 都能直接写:

fn main() {
    let ready = true;
    let letter = '中';
    let emoji = '🦀';
    println!("{ready} {letter} {emoji}");
}

但 char 不一定等于人眼感知到的“一个字符”:一个字形簇(grapheme cluster)可能由多个 Unicode 标量值组成。字符串和 UTF-8 的细节留到后续章节。

复合类型

复合类型把多个值组合起来,基础类型有元组和数组。元组长度固定、元素类型可不同;可用模式解构,也可用 .0、.1 访问:

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("{x} {y} {z}; second = {}", tup.1);
}

没有任何元素的元组写作 (),称为单元类型(unit)。函数没有显式返回值时,实际返回的就是它;因此在 Rust 中“没有返回值”并非没有类型,而是返回 ()。

数组的元素类型相同、长度固定,类型写作 [元素类型; 长度];[值; 长度] 可以用同一个初值填充。数组适合固定数量的数据,可以存放在栈上;如果需要动态增删元素,应该使用 Vec。

fn main() {
    let months = ["Jan", "Feb", "Mar"];
    let zeros = [0; 5];
    let first = months[0];
    println!("{first}; {} 个零;数组长度 {}", zeros.len(), months.len());
}

数组访问会进行运行时边界检查:当下标来自用户输入时,编译器无法预先判断其是否有效;一旦越界,程序会 panic,而不会继续读写未知内存。这一次额外检查,换来的是内存安全。

0x03 函数与表达式

函数

函数用 fn 声明,语法如下:

fn main() {
	add(1,2);
}

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

main 函数是特殊的函数,是程序的入口。

函数参数的类型必须显式标注,Rust 不会对函数参数做类型推导,这一点和 let 不同。原因在于:函数是模块的边界,无论是读代码的人还是做增量编译的编译器,都需要一眼看清接口签名,而不是钻进函数体去反推参数类型。

返回值用 -> 声明。注意上面 add 函数的最后一行是 a + b,没有分号——这个表达式的值就是函数的返回值。

语句与表达式

这就涉及 Rust 一个非常核心的设计:表达式导向。

  • 语句执行一个动作,不产生值,比如 let x = 5;。
  • 表达式计算出一个值,比如 x + 5、add(1, 2),甚至一个代码块 { ... }。

分号是语句和表达式的分水岭:给表达式末尾加上分号,它就变成了语句,值被丢弃,类型变为 ()。这意味着代码块本身可以有值, if 也可以有值:

fn main() {
    let y = {
        let x = 3;
        x + 1 // 块的最后一个表达式就是块的值
    };
    println!("y = {y}"); //  y = 4

    let desc = if y > 3 { "大" } else { "小" }; // if 直接当表达式用
    println!("{desc}"); // 大
}

这个特性能简化不少代码:在很多语言里需要先声明一个变量、再在 if 分支里赋值,Rust 里可以一步完成。

但新手最容易踩的坑也在这里——函数体最后一行多写了一个分号:

fn add(a: i32, b: i32) -> i32 {
    a + b; // 分号把表达式变成了语句,返回值成了 ()
}

这会报 error[E0308]: mismatched types,提示 expected i32, found ()。看到这个报错,首先应该检查:**是不是最后一行多打了个分号 **。

注释

注释有四种:

  • 行注释://,// 之后的本行内容均为注释。
  • 块注释:/* */,支持跨行书写。块注释支持嵌套。
  • 外部文档注释:///,面向调用者,可通过 rustdoc 生成 API 文档。
  • 模块文档注释://!,置于文件头部,用于描述当前整个模块。

/// 和 //! 里的代码示例会被 cargo test 当测试跑,文档里的例子写错了,测试就会挂。

0x04 控制流

if-else 条件判断

if 按条件选择分支,语法和大多数语言类似。Rust 有两个特点:条件**必须是 bool 类型 **,不会像 C、JavaScript、Python 那样把非零、非空值隐式当作 true;以及 if 是表达式,可以直接用于赋值。

fn main() {
    let number = 6;
    if number % 2 == 0 {
        println!("偶数");
    } else {
        println!("奇数");
    }

    let parity = if number % 2 == 0 { "偶" } else { "奇" };
    println!("{parity}");
}

循环

Rust 有三种循环,选哪个看场景:

循环 什么时候用 怎么退出 能带出值吗
loop 无限循环,或要中途退出并返回一个值 break 能
while 次数未知,但有明确停止条件 条件变 false 不能
for 遍历集合或范围 遍历完 不能

loop 是无限循环,通过 break 退出,而且 break 可以带出一个值——这在其他语言中比较少见:

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // 带出 20
        }
    };
    println!("result = {result}");
}

嵌套循环时还可以给循环添加标签,精确跳出指定的那一层:

fn main() {
    'outer: loop {
        loop {
            break 'outer; // 直接跳出外层
        }
    }
}

while 就是带条件的循环:

fn main() {
    let mut n = 3;
    while n != 0 {
        println!("{n}!");
        n -= 1;
    }
    println!("发射!");
}

最常用的是 for 循环,用于遍历集合或范围,不需要手动管理边界:

fn main() {
    for element in [10, 20, 30] {
        println!("{element}");
    }
    for (i, v) in ["a", "b"].iter().enumerate() {
        println!("{i}: {v}");
    }
    for n in (1..=3).rev() {
        println!("{n}!"); // 3! 2! 1!
    }
}

能用 for 就不要手写 while 加下标。手写下标意味着需要自己维护边界,也就多了一处可能越界的地方; for 把这件事交给迭代器,代码更短,也更不容易出错。

范围语法

.. 和 ..= 表示区间,最常用于 for 和切片:

写法 含义 例子
a..b 左闭右开,不含 b 1..5 : 1, 2, 3, 4
a..=b 左闭右闭,含 b 1..=5 : 1, 2, 3, 4, 5
fn main() {
    for i in 1..5 {
        print!("{i} "); // 1 2 3 4
    }
    println!();
    for i in 1..=5 {
        print!("{i} "); // 1 2 3 4 5
    }
    println!();
}

0x05 写在最后

这一篇覆盖了 Rust 的基础语法,更多内容会在后续逐步展开。贯穿其中的是 Rust 的核心设计倾向:

  • 默认不可变:变量默认不可变,可变需要显式声明,让编译器能做静态校验;
  • 静态类型 + 强推导:类型必须在编译期确定,但优先由编译器推导,减少手动标注;
  • 表达式导向:代码块、if、loop 都可以求值,减少中间变量;
  • 控制流条件严格为布尔值:不做隐式真值转换,边界条件必须显式写出。

这些设计的共同指向,是在编译期尽可能多地捕获错误。初学阶段频繁遇到编译报错,其实是编译器在替你提前排查问题。

理解了这套思路,再去看 Rust 的所有权、借用等高级特性,会顺畅很多。