Rust基础语法
学 Rust 之前先说一件事:它和你之前学过的语言不太一样。
C/C++ 让你手动管内存——好处是快、坏处是各种崩溃。Java/Go/Python 有 GC——好处是省心、坏处是运行时开销、暂停。
Rust 走了第三条路:编译期就把内存管理规则查清楚——没有 GC、没有手动 free、但也不会崩。代价是你要学一套新的编程模型(所有权),编译器会不停跟你吵架。
这一章先跳过所有权(第 3 章讲),把基本语法过一遍——变量、函数、控制流、基础类型。这些和别的语言差别不大,容易上手。
1. Hello World
fn main() {
println!("Hello, world!");
}
几个观察:
fn关键字定义函数(不是def、不是function);main是程序入口;println!后面有个!——它不是普通函数,是宏(后面章节讲);- 语句以
;结尾。
运行:
# 用 cargo(推荐)
cargo new hello
cd hello
cargo run
# 或者用 rustc 直接编译
rustc hello.rs
./hello
Rust 是编译型语言——每次跑要先编译。debug build 快(几秒),release build 慢(几十秒到几分钟)。
2. 变量
let x = 5;
let y: i32 = 10; // 显式标注类型
默认不可变。这是 Rust 一个非常重要的默认——变量声明后不能改:
let x = 5;
x = 6; // 编译错误!
要可变要显式加 mut:
let mut x = 5;
x = 6; // 现在可以了
为什么默认不可变?这是 Rust 的哲学——大多数变量其实不需要变,标记 mut 让改动的地方一目了然。写多了你会发现这条帮助非常大——看到 mut 就知道这里有状态变化,要小心。
变量遮蔽(shadowing):可以用 let 重新声明同名变量,甚至类型不同:
let x = 5;
let x = "hello"; // 完全合法,x 现在是字符串
这和 mut 是两回事——遮蔽是创建了新变量,类型可以变。
常量用 const:
const MAX_SIZE: u32 = 100_000;
常量必须显式标类型,编译期确定,可以在任何作用域用。
3. 基本类型
整数:i8、i16、i32、i64、i128、isize(signed),u8-u128、usize(unsigned)。
- 默认
i32; isize/usize是"指针大小"——64 位机器上是 64 位;- 数字字面量可以带下划线增加可读性:
1_000_000; - 可以带后缀:
123i64、3.14f32。
浮点:f32、f64。默认 f64。
布尔:bool——true / false。
字符:char——4 字节的 Unicode 标量(不是 C 里的 1 字节 char):
let c = 'A';
let emoji = '😀'; // 完全合法
元组:
let t = (1, "hello", 3.14);
let (a, b, c) = t; // 解构
let first = t.0; // 通过索引访问
数组:固定长度(长度是类型的一部分):
let arr = [1, 2, 3, 4, 5]; // 类型是 [i32; 5]
let zeros = [0; 100]; // 100 个 0
let x = arr[0];
动态长度用 Vec(后面讲)。
4. 函数
fn add(x: i32, y: i32) -> i32 {
x + y // 注意:没有分号!这是返回值
}
几个特点:
- 参数必须标类型;
- 返回类型用
->; - 最后一个表达式没有分号就是返回值——加了分号就变成语句,返回
(); - 可以显式
return——但风格上都用"末尾表达式"。
块表达式:Rust 里几乎什么都是表达式:
let y = {
let x = 3;
x + 1 // 这个块的值是 4,赋给 y
};
if 也是表达式:
let x = if condition { 5 } else { 6 };
这个特性让 Rust 代码经常没有 return 语句——函数体最后一行的值就是返回值。
5. 控制流
if:
let n = 5;
if n > 0 {
println!("positive");
} else if n < 0 {
println!("negative");
} else {
println!("zero");
}
没有 C 风格的 if (n > 0) {}——条件不用括号,但 {} 必须要。
注意:条件必须是 bool,不能是整数。if n {} 是错的。
loop:无限循环,配合 break 和 continue:
let result = loop {
// 干点事
if done {
break 42; // 从 loop 返回值!
}
};
loop 可以带返回值——这是很多其他语言没有的特性。
while:
while n > 0 {
n -= 1;
}
for:Rust 的 for 只能遍历迭代器:
for i in 0..10 { // 0..10 是 range,[0, 10)
println!("{}", i);
}
for i in 0..=10 { // [0, 10],包含 10
println!("{}", i);
}
for x in vec![1, 2, 3] {
println!("{}", x);
}
没有 C 风格的 for(i=0; i<n; i++)——用 for i in 0..n 代替。更少的错误、更清晰的意图。
match:一个非常强大的模式匹配:
let x = 5;
match x {
1 => println!("one"),
2 | 3 => println!("two or three"),
4..=9 => println!("four to nine"),
_ => println!("other"),
}
match 必须穷尽所有可能——如果你忘了 _(通配符),编译器会报错。这个特性是 Rust 里最"救命"的东西之一——加了一个新的枚举分支?编译器立刻告诉你所有 match 都要更新。
6. 字符串:两种类型
Rust 里字符串有两个类型,是新手最容易犯的坑:
String:堆上分配、可变、可增长的字符串:
let mut s = String::from("hello");
s.push_str(", world");
&str:字符串切片——引用一段字符串数据,本身不拥有:
let s: &str = "hello"; // 字符串字面量的类型是 &'static str
let slice = &some_string[0..5]; // 从 String 里切出一段
关系:
String拥有堆上的字符串数据;&str只是一段"借来看看"的引用;- 函数参数几乎永远用
&str——更通用; - 只有需要修改或者拥有时才用
String。
经典写法:
fn greet(name: &str) { // 参数是 &str
println!("Hello, {}", name);
}
let s = String::from("world");
greet(&s); // String 可以自动转 &str
greet("world"); // 字面量也是 &str
这两个类型的区别是很多新手的入门槛——记住"参数用 &str、要改就 String"就基本够用。
7. Vec:可变数组
对应 Java 的 ArrayList、Python 的 list、C++ 的 vector:
let mut v: Vec<i32> = Vec::new();
v.push(1);
v.push(2);
v.push(3);
// 用宏更简单
let v = vec![1, 2, 3];
// 访问
let first = v[0]; // 直接索引(越界会 panic)
let maybe_first = v.get(0); // 返回 Option<&i32>(安全)
// 遍历
for x in &v {
println!("{}", x);
}
Vec 是最常用的容器——存一堆同类型的东西。
8. 结构体和方法:小尝试
正式讲结构体在第 2 章,这里先看一眼:
struct Point {
x: f64,
y: f64,
}
impl Point {
fn new(x: f64, y: f64) -> Self {
Self { x, y }
}
fn distance(&self, other: &Point) -> f64 {
let dx = self.x - other.x;
let dy = self.y - other.y;
(dx * dx + dy * dy).sqrt()
}
}
let p1 = Point::new(1.0, 2.0);
let p2 = Point::new(3.0, 4.0);
let d = p1.distance(&p2);
关键点:
- 数据(
struct)和方法(impl)分开定义——不像 C++/Java 一个类包所有; - 方法的第一个参数是
&self/&mut self/self——决定方法怎么访问对象; Self(大写)是"当前类型"的别名——写起来省字。
9. 打印和格式化
打印:
println!("Hello");
println!("x = {}", x);
println!("x = {}, y = {}", x, y);
println!("x = {x}, y = {y}"); // 直接用变量名(Rust 2021+)
格式说明符:
{}:Display trait(用户可读);{:?}:Debug trait(调试用);{:#?}:Debug 的"pretty print"(带换行缩进);{:.2}:小数点后 2 位;{:>10}:右对齐宽度 10。
为什么有两个 {} 和 {:?}:
{}是给最终用户看的——像"3.14";{:?}是给开发者看的——像"Point { x: 3.14, y: 2.71 }"。
你自定义的类型默认不能被 println——需要 derive 或者手动实现 Display / Debug:
#[derive(Debug)]
struct Point { x: f64, y: f64 }
let p = Point { x: 1.0, y: 2.0 };
println!("{:?}", p); // 现在可以了
10. 一些常见的坑(新手会踩)
整数溢出:debug build 里溢出会 panic,release build 里会 wrap。这是很多 C 程序员意料之外的行为。
类型不能隐式转换:
let x: i32 = 5;
let y: i64 = x; // 编译错误!
let y: i64 = x as i64; // 显式转换
Rust 极其严格——没有隐式的数值转换。这防止了一大类 bug。
除法保留类型:
let x = 5 / 2; // = 2(整数除法)
let x = 5.0 / 2.0; // = 2.5
布尔不能当条件之外的东西用:
let x: i32 = true; // 错,不能把 bool 当 i32
let x = if true { 1 } else { 0 }; // 要用 if
返回值别加分号:
fn add(x: i32, y: i32) -> i32 {
x + y; // 错!分号让这变成语句,返回 ()
}
fn add(x: i32, y: i32) -> i32 {
x + y // 对
}
这是新手最容易懵的地方——看到编译错误 "expected i32, found ()",多半是这个。
11. Cargo:Rust 的构建工具
Cargo 是 Rust 生态的核心——它做包管理、构建、测试、发布:
cargo new my_project # 新项目
cargo new my_lib --lib # 新库
cargo build # 编译 debug
cargo build --release # 编译 release(优化)
cargo run # 编译并运行
cargo test # 跑测试
cargo add serde # 添加依赖
cargo clippy # 静态检查(比 rustc 更严格)
cargo fmt # 格式化代码
项目结构:
my_project/
├── Cargo.toml # 依赖 + 元信息
├── Cargo.lock # 锁定依赖版本
├── src/
│ ├── main.rs # 可执行文件入口
│ └── lib.rs # 库入口
└── target/ # 编译产物(.gitignore 掉)
Cargo.toml 示例:
[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
Cargo 是 Rust 生态最大的加分项——比 C++/Java 的构建工具好用得多。
12. 一些工程建议
编译报错不要害怕——Rust 的编译器是你最好的老师。它的错误信息在业界最详细:
- 指出具体位置;
- 解释为什么错;
- 给出可能的修复;
- 甚至有
--explain E0001详细解释某个错误码。
多用 cargo clippy:它会给出比 rustc 更严格的建议,很多"能编译但风格不好"的地方都能被抓到。
cargo fmt 自动格式化:让所有 Rust 代码风格统一,别为了缩进浪费时间。
别急着写 unsafe:新手很容易被 borrow checker 折磨,然后想"我用 unsafe 绕开"——99% 的场景不需要 unsafe,你只是没找到正确的模式。先学好 safe Rust。
读别人的代码:Rust 的错误信息虽好,但一些常见 pattern 需要你从别人代码里学。tokio、serde、reqwest 这些主流库的代码风格值得看。
13. 一句话总结
Rust 基础语法要点:
- 变量默认不可变,需要
mut; - 函数返回值是最后一个表达式(不加分号);
if、match、loop都是表达式;- 两种字符串:
String(拥有)和&str(借用); match必须穷尽——这是好事;- 类型严格:没有隐式转换;
- Cargo 是你最好的工具。
这一章只是热身,Rust 真正的核心在下一章开始的类型系统、所有权、生命周期。这些是让 Rust "既快又安全"的秘密——也是学习曲线最陡的地方。