一切从 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 的所有权、借用等高级特性,会顺畅很多。