Rust 基础语法
本章面向刚接触 Rust 的读者,只讲最基础的语法:怎么声明变量、有哪些数据类型、怎么写函数、怎么写条件判断和循环。不涉及所有权、生命周期等进阶话题(那些在后面的章节里)。
学完本章,你应该能看懂并写出简单的 Rust 程序,比如:用循环打印九九乘法表、用 if 判断成绩等级。
1. 第一个程序
一个最小的 Rust 程序长这样:
fn main() {
println!("Hello, world!");
}
逐个拆解:
fn是 function(函数)的关键字,main是程序的入口,程序从这里开始执行。println!("...")是打印一行文字的宏(后面带!的都是宏,可以先当成特殊的函数用)。- 每条语句以分号
;结尾。 - 花括号
{}包住函数体。
实际开发中我们用 cargo 管理项目:
cargo new hello # 创建一个名为 hello 的新项目
cd hello
cargo run # 编译并运行
cargo check # 只检查代码能否编译,速度更快
cargo build # 只编译不运行
2. 变量与 let
2.1 变量默认不可变
Rust 最"反直觉"的一点:用 let 声明的变量默认不可变(immutable) ,赋值后再改会报错。
fn main() {
let x = 5;
// x = 6; // ❌ 编译错误:cannot assign twice to immutable variable
println!("x = {}", x);
}
想修改变量,要加 mut(mutable 的缩写):
fn main() {
let mut x = 5;
println!("x = {}", x); // x = 5
x = 6;
println!("x = {}", x); // x = 6
}
为什么要默认不可变?这是 Rust 的设计哲学:默认值应该是最安全的选项。大部分变量其实不需要改,默认不可变能帮你避免很多意外的修改。需要改的时候显式写 mut,读代码的人一眼就知道"这个变量会变"。
2.2 声明时必须初始化
Rust 不允许使用未初始化的变量:
fn main() {
let x: i32;
// println!("{}", x); // ❌ 编译错误:使用了可能未初始化的变量
x = 10; // ✅ 先赋值后使用是可以的
println!("{}", x);
}
2.3 遮蔽(Shadowing)
你可以用 let 重新声明一个同名变量,新变量会"遮蔽"旧变量:
fn main() {
let x = 5;
let x = x + 1; // 遮蔽上一个 x,现在 x 是 6
let x = x * 2; // 再次遮蔽,现在是 12
println!("x = {}", x);
// 遮蔽甚至可以改变类型!
let spaces = " "; // &str 类型
let spaces = spaces.len(); // usize 类型,这是合法的
}
遮蔽和 mut 的区别:
mut | 遮蔽 | |
|---|---|---|
| 能否改值 | ✅ 直接赋值改 | ✅ 重新 let 一次 |
| 能否改类型 | ❌ 不能 | ✅ 能 |
| 是否产生新变量 | ❌ 还是同一个 | ✅ 是新变量 |
遮蔽在转换场景很常用(比如把字符串解析成数字后还叫同一个名字),不用绞尽脑汁想 x_str、x_num 这种变量名。
3. 基本数据类型
Rust 是静态类型语言:每个变量的类型在编译期就确定了。
3.1 整数
| 类型 | 位数 | 范围 |
|---|---|---|
i8 / u8 | 8 位 | -128 |
i16 / u16 | 16 位 | 有符号 / 无符号 |
i32 / u32 | 32 位 | i32 是默认整数类型 |
i64 / u64 | 64 位 | 大数场景 |
i128 / u128 | 128 位 | 极大数 |
isize / usize | 随平台 | 索引、集合长度用 usize |
i开头是有符号(可正可负),u开头是无符号(只有 ≥ 0)。- 不写类型注解时,整数默认是
i32。
fn main() {
let a: i32 = 42; // 显式指定类型
let b = 42i64; // 数字后缀指定类型
let c = 1_000_000; // 下划线分隔,提高可读性
let hex = 0xff; // 十六进制
let bin = 0b1010; // 二进制
let byte = b'A'; // u8 字节
println!("{} {} {} {} {} {}", a, b, c, hex, bin, byte);
}
整数溢出:debug 模式下溢出会直接 panic(程序崩溃),release 模式下会回绕。不确定就用 i32/i64,别抠位数。
3.2 浮点数
fn main() {
let x = 2.5; // 默认 f64(双精度,推荐)
let y: f32 = 3.14; // f32(单精度)
println!("{} {}", x, y);
}
3.3 布尔与字符
fn main() {
let t = true;
let f: bool = false;
let c = 'z'; // char 用单引号
let heart = '❤'; // char 是 4 字节 Unicode,能存中文和 emoji
println!("{} {} {} {}", t, f, c, heart);
}
注意区分:字符 'a' 用单引号,字符串 "a" 用双引号。
3.4 字符串速览
基础阶段记住两种:
fn main() {
let s1 = "hello"; // &str:字符串字面量(切片),不可变
let s2 = String::from("hello"); // String:拥有所有权的字符串,可增长
let s3 = String::new(); // 空字符串
// 常用操作
let s = String::from("你好");
let len = s.len(); // 字节数(中文一个字 3 字节)
let upper = "abc".to_uppercase(); // 转大写
let combined = format!("{}-{}", s1, s2); // 拼接推荐用 format!
println!("{} {} {} {}", len, upper, combined, s3.is_empty());
}
字符串进阶(所有权、切片、生命周期)见第 01、07 章。
3.5 类型转换
Rust 不会自动做隐式类型转换,必须显式转换:
fn main() {
let x: i32 = 10;
let y: f64 = x as f64; // as:基础类型间转换
let z: i64 = i64::from(x); // From/Into 转换
let w: i32 = 100.into();
// 字符串解析成数字,返回 Result
let n: i32 = "42".parse().expect("不是合法数字");
println!("{} {} {} {}", y, z, w, n);
}
4. 元组与数组(复合类型速览)
fn main() {
// 元组:可以装不同类型的值,长度固定
let person: (&str, i32) = ("小明", 18);
let (name, age) = person; // 解构
println!("{} 今年 {} 岁", name, person.1); // 索引访问用 .1
// 数组:同一类型,长度固定
let arr = [1, 2, 3, 4, 5];
let zeros = [0; 3]; // [0, 0, 0]
let first = arr[0]; // 越界访问会 panic
println!("{} {} {} {}", name, age, first, zeros[2]);
}
长度可变的集合用 Vec(向量)和 HashMap
5. 函数
fn main() {
let sum = add(3, 5);
println!("3 + 5 = {}", sum);
greet("小明");
// 函数的最后一行表达式就是返回值(不写分号!)
let doubled = double(21);
println!("21 翻倍 = {}", doubled);
}
// fn 函数名(参数: 类型) -> 返回类型
fn add(a: i32, b: i32) -> i32 {
a + b // 注意:没有分号,这是表达式,作为返回值
}
// 没有返回值的函数不用写 ->
fn greet(name: &str) {
println!("你好,{}!", name);
}
fn double(x: i32) -> i32 {
// return x * 2; // 也可以用 return 提前返回
x * 2
}
关键规则:
- 参数必须标注类型,返回值用
-> 类型标注。 - 函数体最后一个不带分号的表达式就是返回值。如果加了分号,它就变成语句,返回值就是
()(空元组,类似其他语言的 void)——这是新手最常见的编译错误来源:
fn add(a: i32, b: i32) -> i32 {
a + b; // ❌ 加了分号,返回 () 而不是 i32,编译报类型不匹配
}
6. 注释与打印
fn main() {
// 这是行注释
/* 这是
块注释 */
let x = 5;
// println! 的占位符用法
println!("普通打印:{}", x);
println!("变量名内插:x = {x}"); // 直接把变量名写进 {}(Rust 2021+)
println!("调试打印:{:?}", [1, 2, 3]); // {:?} 打印数组和结构体的调试格式
println!("保留两位小数:{:.2}", 3.14159);
// print! 不换行,println! 换行
print!("不换行");
println!("换行");
}
7. 控制流
7.1 if / else if / else
条件不需要括号,但花括号必须有:
fn main() {
let score = 85;
if score >= 90 {
println!("优秀");
} else if score >= 60 {
println!("及格");
} else {
println!("不及格");
}
// if 是表达式,可以用来赋值(类似三目运算符,但类型必须一致)
let level = if score >= 60 { "及格" } else { "不及格" };
println!("等级:{}", level);
}
注意:Rust 没有 if (score >= 60) { ... } 这种条件外带括号的写法——可以写但编译器会警告,而且 Rust 风格是不加括号。
7.2 loop:无限循环
loop 创建一个死循环,用 break 跳出。它的特别之处:break 可以带返回值。
fn main() {
let mut count = 0;
let result = loop {
count += 1;
if count == 10 {
break count * 2; // break 带值,整个 loop 表达式的值就是 20
}
};
println!("result = {}", result); // 20
}
continue 跳过本轮循环,进入下一轮。
7.3 while:条件循环
fn main() {
let mut n = 3;
while n > 0 {
println!("{}!", n);
n -= 1;
}
println!("发射!");
}
7.4 for:遍历循环(最常用)
Rust 的 for 只用来遍历,不写 C 风格的 for (i = 0; i < 10; i++)。用区间(Range)代替:
fn main() {
// 0..5 表示 0,1,2,3,4(不含 5)—— 左闭右开
for i in 0..5 {
print!("{} ", i);
}
println!();
// 0..=5 表示 0,1,2,3,4,5(含 5)—— 闭区间
for i in 0..=5 {
print!("{} ", i);
}
println!();
// 反向循环
for i in (1..4).rev() {
print!("{} ", i);
}
println!();
// 遍历数组
let arr = [10, 20, 30];
for x in arr {
print!("{} ", x);
}
println!();
// 需要下标时用 .enumerate()
for (i, x) in arr.iter().enumerate() {
println!("第 {} 个元素是 {}", i, x);
}
}
九九乘法表练手:
fn main() {
for i in 1..=9 {
for j in 1..=i {
print!("{}x{}={}\t", j, i, i * j);
}
println!();
}
}
7.5 标签:跳出多层循环
嵌套循环中想直接跳出外层,给循环打标签:
fn main() {
'outer: for i in 1..4 {
for j in 1..4 {
if i * j > 4 {
break 'outer; // 直接终止外层循环
}
print!("({},{}) ", i, j);
}
}
println!();
}
8. 一个综合小例子
猜数字游戏的雏形,串起本章所有知识点:
use std::cmp::Ordering;
fn main() {
let secret = 42; // 不可变变量
let mut attempts = 0; // 可变计数器
let guesses = [50, 30, 42]; // 模拟三次猜测
for guess in guesses {
attempts += 1;
println!("第 {} 次猜测:{}", attempts, guess);
match guess.cmp(&secret) {
Ordering::Less => println!("太小了"),
Ordering::Greater => println!("太大了"),
Ordering::Equal => {
println!("猜对了!共用了 {} 次", attempts);
break;
}
}
}
}
这里的 match 是 Rust 强大的模式匹配
9. 易错点与陷阱
- 忘了分号 / 多了分号:语句要分号,函数最后一行的返回值表达式不要分号。
- 整数类型混算:
i32 + u64会编译报错,Rust 不做隐式转换,用as统一类型。 ..和..=搞混:0..5不含 5,0..=5含 5。- char 用单引号、字符串用双引号:写反了会报错。
- 不可变变量赋值:报 “cannot assign twice to immutable variable” 就加
mut。 - 整数溢出:
u8最大 255,255 + 1在 debug 下 panic。 - 数组越界:
arr[10]编译可能通过,运行时 panic。
10. 最佳实践
- 变量默认
let,确实需要修改才加mut。 - 整数拿不准就用
i32,集合索引用usize。 - 拼接字符串用
format!,不要手动+(所有权问题,见第 01 章)。 - 循环优先用
for+ 区间;while用于条件不明确的场景;loop用于真正的死循环 +break返回值。 - 用
{x}变量名内插代替{}+ 参数列表,更不容易对错位置。 - 经常跑
cargo check快速发现编译错误,比cargo run快。
11. 要点回顾
let声明变量,默认不可变;mut声明可变变量;同名let是遮蔽。- 类型系统:
i32默认整数,f64默认浮点,转换必须显式(as)。 - 函数参数必须标类型,最后一个表达式(无分号)是返回值。
if是表达式可以赋值;条件不加括号。- 三种循环:
loop(死循环,break可带值)、while(条件循环)、for(遍历区间/集合,最常用)。 break '标签跳出多层循环。