CHAPTER 01 · 入门基础
初识 Rust 与 Cargo
一句话总览:Rust = C/C++ 级性能 + 无 GC 的内存安全,秘诀是把安全检查全部搬到编译期——编译器像一个严厉但讲道理的安检员,过了安检的程序几乎不会有内存错误。
🛂
生活化类比
JS/Go 像先放行、出事再处理的车站:空指针、数据竞争等问题在运行时才爆炸(GC 是随时跟着打扫的保洁员)。Rust 像登机前全身安检:借用检查器就是安检门,带危险品(悬垂引用、双重释放)根本登不了机,所以飞行中不需要保洁员(无 GC、零运行时开销)。类比边界:安检只查「危险品」——内存与并发安全;它不保证你的业务逻辑正确,编译通过的程序照样能算错账。
JS/Go 像先放行、出事再处理的车站:空指针、数据竞争等问题在运行时才爆炸(GC 是随时跟着打扫的保洁员)。Rust 像登机前全身安检:借用检查器就是安检门,带危险品(悬垂引用、双重释放)根本登不了机,所以飞行中不需要保洁员(无 GC、零运行时开销)。类比边界:安检只查「危险品」——内存与并发安全;它不保证你的业务逻辑正确,编译通过的程序照样能算错账。
1.1 和你熟悉的语言比一比
| 维度 | JS / TS | Go | C / C++ | Rust |
|---|---|---|---|---|
| 内存管理 | GC | GC | 手动 malloc/free | 所有权,编译期自动插入释放 |
| 空值 | null / undefined | nil(可 panic) | 空指针(UB) | 没有 null,用 Option<T> 强制处理 |
| 数据竞争 | 单线程回避 | 运行时才可能发现 | 靠自觉 | 编译期直接拒绝 |
| 运行性能 | 解释 + JIT | 接近原生 | 原生 | 原生(LLVM 同款后端) |
| 类型系统 | TS 编译期检查、运行时擦除 | 静态、较简单 | 静态、较弱 | 静态强类型 + trait + 泛型单态化 |
| 上手曲线 | 平缓 | 平缓 | 陡峭(坑在运行时) | 陡峭(坑在编译期) |
对前端同学最直观的翻译:TS 的类型检查在打包后就消失了,Rust 的「类型检查」连内存怎么释放、谁能改数据都管,而且一直管到机器码生成之前。
1.2 工具链:rustup 装工具,cargo 管项目
终端 · 日常命令
rustup update // 更新工具链(rustc 编译器 + cargo 都归它管)
cargo new hello_rust // 新建项目:生成 Cargo.toml + src/main.rs
cargo run // 编译并运行(开发期最常用)
cargo check // 只做类型/借用检查,不生成二进制 → 秒级反馈
cargo build --release // 优化编译,产物在 target/release/
cargo test // 跑所有测试
cargo fmt // 官方格式化(对标 prettier)
cargo clippy // 官方 lint(对标 eslint,建议天天跑)Cargo.toml ≈ package.json(依赖声明),Cargo.lock ≈ lockfile,crates.io ≈ npm 仓库,一个「crate」就是一个包/编译单元。
src/main.rs
fn main() { // fn 声明函数;main 是入口
let name = "Rust"; // let 绑定变量,默认不可变
println!("Hello, {}!", name); // println! 带 ! 的是宏,不是函数
}编译管线:错误在哪个阶段被拦下
Rust 把「运行时才爆炸的问题」前移到编译期,这就是「编译通过 ≈ 内存安全」的来源。
⚠ 高频陷阱:把编译器当敌人
新手看到满屏红色报错就烦躁、随手加 clone() 或 unsafe 硬糊过去 → 后果是埋下性能坑或真正的未定义行为。正确姿势:Rust 的报错是「附带修复建议的教学材料」,先读错误码和箭头指向的行,运行 rustc --explain E0382 还能看官方讲解。✓ 记忆锚点
「rustup 管工具,cargo 管项目;改两行就 check,要跑才 run。」1.3 随堂自测
QUIZ 1
Rust 程序中的「使用已释放内存」这类错误,通常在什么阶段被拦截?
Rust 没有 GC,也没有运行时内存异常兜底:所有权与借用规则在编译期就排除了这类错误,这正是它「无 GC 却内存安全」的核心机制。C++ 才主要靠 D。
QUIZ 2
改了几行代码想快速确认「能不能编过」,最省时间的命令是?
check 只跑前端分析与借用检查,跳过优化和代码生成,反馈最快。build --release 要全量优化最慢;run/test 都会先生成二进制,属于「确认能编过」之外的额外工作。
CHAPTER 02 · 入门基础
变量、可变性与基本类型
一句话总览:Rust 变量默认不可变,要改必须显式
mut;类型推断很强但仍是静态类型——一个绑定的类型编译期钉死,想「换类型」用遮蔽(shadowing)而不是改原变量。📦
生活化类比
let x = 5; 是封死的展示盒:贴了标签 x,内容不许换。let mut x = 5; 是带盖收纳盒:同一只盒子,内容可以换,但盒子规格(类型)不变。遮蔽 let x = "hi"; 则是买一只新盒子贴同样的标签,旧盒子直接回收——所以新盒子可以是完全不同的规格。类比边界:JS 的 let 更像「标签随便贴到哪只盒子上都行」,Rust 的 mut 只许换内容、不许换盒子。2.1 let / mut / const
bindings.rs
let a = 5; // 不可变绑定,类型推断为 i32
// a = 6; // ❌ 编译错误 E0384:不能给不可变变量二次赋值
let mut b = 5; // 显式声明可变
b = 6; // ✓ 同一只盒子换内容
let c: u64 = 100; // 显式标注类型(推断不出或有歧义时必须写)
const MAX_RETRY: u32 = 3; // 常量:必须标类型、编译期可求值、全大写命名
// const 与 let 的区别:const 永远不可变、可在全局声明,类似 TS 的字面量常量2.2 遮蔽(shadowing)≠ 可变
shadow.rs
let x = 5;
let x = x + 1; // ✓ 新绑定遮蔽旧的,x = 6(旧的 5 已不可访问)
let x = "six"; // ✓ 连类型都能换:i32 → &str,因为是全新变量
let mut s = "hi";
// s = 6; // ❌ mut 只许改值,不许改类型(&str 盒子装不下整数)
let spaces = " ";
let spaces = spaces.len(); // 经典用法:字符串 → 长度,复用名字且全程不可变mut 改内容 vs shadowing 换盒子
mut 是「一只盒子反复用」,shadowing 是「新盒子顶掉旧标签」——所以只有后者能换类型。
2.3 标量类型速查
| 类别 | 类型 | 说明 |
|---|---|---|
| 有符号整数 | i8 i16 i32 i64 i128 | 数字 = 位数;默认推断 i32,范围约 ±21 亿 |
| 无符号整数 | u8 u16 u32 u64 u128 | 只存非负数;u8 常用来存字节 |
| 指针宽度 | isize / usize | 随平台 32/64 位;索引、长度一律 usize |
| 浮点 | f32 / f64 | 默认 f64;同样有 0.1+0.2 ≠ 0.3 问题 |
| 布尔 | bool | 只有 true/false,数字不能当布尔用(if 1 报错) |
| 字符 | char | 4 字节 Unicode 标量,'中'、'🦀' 都是一个 char |
⚠ 高频陷阱:整数溢出的两副面孔
let x: u8 = 255; let y = x + 1; → debug 构建直接 panic,release 构建静默回绕成 0——同一份代码两种行为,线上出「金额变 0」的静默事故。正确姿势:明确表达意图:checked_add(返回 Option)、wrapping_add(明确要回绕)、saturating_add(封顶)。✓ 记忆锚点
「默认不可变,要改加 mut;mut 换内容,遮蔽换盒子;索引长度 usize,字符 4 字节存天下。」2.4 随堂自测
QUIZ 1
let x = 5; let x = x.to_string(); 这段代码的结果是?这是 shadowing:第二个 let 声明了全新绑定,与旧 x 无关,所以既不需要 mut,也允许换类型。A/B 把它误当成「给旧变量赋值」;Rust 静态类型不存在 D 之外的运行时类型错误。
QUIZ 2
let x: u8 = 255; let y = x + 1; 在 debug 与 release 构建下分别会怎样?Rust 在 debug 构建插入溢出检查(panic 提示你),release 为性能移除检查、按二进制补码回绕。这不是编译错误(值依赖运行时),所以 D 错;想行为一致就用 checked_add / wrapping_add 显式表态。
CHAPTER 03 · 入门基础
函数、控制流与表达式
一句话总览:Rust 是面向表达式的语言:if、循环、代码块都能「产出一个值」;而分号是消音器——表达式加上分号就变成语句,值被丢弃、只剩
()。🏭
生活化类比
表达式像出货的机器:运转完从出口吐出一件产品(值)。语句像只干活不出货的机器(比如碎纸机)。分号 = 把出口闸门焊死:产品掉在厂房里没人要,对外只交出「干完了」的空回执
表达式像出货的机器:运转完从出口吐出一件产品(值)。语句像只干活不出货的机器(比如碎纸机)。分号 = 把出口闸门焊死:产品掉在厂房里没人要,对外只交出「干完了」的空回执
()。函数体最后一行不加分号,就是把产品放上传送带交给调用者。类比边界:JS 里 if 永远不出货(只能靠三元表达式),Rust 的 if/loop/match 天生就是机器,直接出货。3.1 函数:参数必须标类型,返回值看最后一行
funcs.rs
fn add(a: i32, b: i32) -> i32 { // 参数类型必须写;-> 声明返回类型
a + b // 尾表达式:没有分号 → 这就是返回值
}
fn add2(a: i32, b: i32) -> i32 {
return a + b; // 显式 return 也行,但惯用尾表达式
}
fn log(msg: &str) { // 不写 -> 即返回 ()(单元类型,类似 void)
println!("{}", msg); // println! 本身也是表达式,值为 ()
}3.2 if 是表达式,可以直接赋值
expr_if.rs
let score = 78;
let grade = if score >= 90 { "A" } else if score >= 60 { "B" } else { "C" };
// 相当于 JS 的三元嵌套,但可读得多;注意结尾这个分号属于 let 语句
let n = if score > 50 { 1 } else { "fail" };
// ❌ 编译错误:两个分支类型不一致(i32 vs &str),if 的值必须有唯一类型
if score { println!("hi"); }
// ❌ 条件必须是 bool,数字不会隐式转布尔(JS 的 truthy 套路在这里失效)3.3 三种循环与区间
loops.rs
let mut count = 0;
let result = loop { // loop:无条件循环,但可以 break 带值出来
count += 1;
if count == 7 { break count * 2; } // result = 14
};
while count > 0 { count -= 1; } // 条件循环
for i in 0..5 { print!("{} ", i); } // 0 1 2 3 4(不含右端)
for i in 0..=5 { print!("{} ", i); } // 0 1 2 3 4 5(含右端)
for ch in "rust".chars() { print!("{} ", ch); } // for 遍历一切迭代器一个分号如何「吞掉」返回值
函数返回的不是「最后执行的东西」,而是「尾表达式的值」——分号一加,尾表达式就没了。
⚠ 高频陷阱:手滑多写一个分号
从 JS 带来的肌肉记忆让你给最后一行加上分号 → 报错 expected i32, found ()(E0308),新手常误以为是返回类型写错。正确姿势:看到 found () 先检查函数/分支最后一行是不是多了分号;编译器通常还会提示「help: remove this semicolon」。✓ 记忆锚点
「无分号返回值,有分号只干活;if 两臂要同型,条件只认 bool。」3.4 随堂自测
QUIZ 1
fn f() -> i32 { 5; } 编译结果是?5; 加了分号成为语句,值被丢弃,函数体尾表达式的类型是 (),与声明的 i32 不符。去掉分号即可;return 不是必需的,所以 D 的「缺少 return」不是真实原因。
QUIZ 2
let x = loop { break 7; }; 执行后 x 的值是?loop 也是表达式,break 可以携带值作为整个 loop 的结果——这是 Rust 里「循环搜索直到命中再交出结果」的惯用法。while/for 不支持 break 带值(它们的值恒为 ()),这是 loop 独有的能力。
CHAPTER 04 · 入门基础
元组、数组与结构体
一句话总览:struct 管「是什么」(数据),impl 管「能干什么」(行为),两者分开写、没有继承;元组是匿名轻量组合,数组定长不可增删——会变长的列表要用第 9 章的 Vec。
🪪
生活化类比
struct 像产品规格表:出厂前印好有哪些字段、每个字段什么型号,实例就是照表造出的一台台机器。impl 像贴在机身上的操作手册:规定这台机器有哪些按钮(方法)可按。前端同学可翻译成:
struct 像产品规格表:出厂前印好有哪些字段、每个字段什么型号,实例就是照表造出的一台台机器。impl 像贴在机身上的操作手册:规定这台机器有哪些按钮(方法)可按。前端同学可翻译成:
struct ≈ TS interface(数据形状),impl ≈ class 的方法区,但 Rust 故意把两者拆开、且禁止继承。类比边界:TS interface 编译后就擦除了,Rust 的 struct 直接决定内存布局——字段挨着放,访问零查表开销。4.1 元组与数组:轻量组合
compound.rs
let t: (i32, f64, &str) = (42, 3.14, "hi"); // 元组:类型可混搭、长度固定
let (a, b, c) = t; // 解构,和 JS 的数组解构手感类似
let first = t.0; // 也可用 .数字 访问
let arr: [i32; 5] = [1, 2, 3, 4, 5]; // 数组:同类型 + 定长,写在栈上
let zeros = [0; 8]; // 8 个 0 的快捷写法
let x = arr[0]; // 索引访问会做越界检查(越界 panic)
// arr.push(6); // ❌ 数组没有 push!长度是类型的一部分:[i32; 5] ≠ [i32; 6]4.2 struct + impl:数据与行为
user.rs
struct User {
name: String, // 字段:名字 + 类型,出厂即定死
age: u32,
}
impl User {
fn new(name: String, age: u32) -> Self { // 关联函数:无 self,用 :: 调用
Self { name, age } // 字段简写;Self = 当前类型
}
fn greet(&self) { // 方法:第一个参数是 self
println!("我是{},{}岁", self.name, self.age);
}
}
let u = User::new(String::from("小豆"), 18); // :: 调关联函数(≈ 静态工厂)
u.greet(); // . 调方法,自动传入 &u
// &self 表示「只读借用自己」,所有权细节见第 6 章4.3 选型速查
| 类型 | 长度 | 元素类型 | 典型场景 |
|---|---|---|---|
元组 (i32, &str) | 固定 | 可混合 | 函数临时返回多个值 |
数组 [i32; 5] | 固定(属于类型) | 必须相同 | 定长缓冲、查表、坐标 |
结构体 struct | 字段固定 | 字段各自声明 | 业务实体:User、Config |
Vec<T>(第 9 章) | 动态增长 | 必须相同 | 列表、队列、收集结果 |
struct 实例的内存布局(对照 JS 对象)
struct 的「字段不可动态添加」换来的是固定内存布局与零开销字段访问。
⚠ 高频陷阱:拿 JS 对象的手感写 struct
想给实例随手挂新字段 u.email = "x" → 编译错误 no field `email`;想不初始化某字段就构造实例 → 同样报错(Rust 没有 undefined 兜底)。正确姿势:可选字段用 Option<T> 声明;真正动态的键值用 HashMap;构造时可用 ..Default::default() 补齐其余字段。✓ 记忆锚点
「数据 struct,行为 impl;:: 找工厂,. 按按钮;定长数组,变长 Vec。」4.4 随堂自测
QUIZ 1
为什么
[i32; 5] 类型的数组不能 push 新元素?[i32; 5] 与 [i32; 6] 是不同类型,长度编译期钉死,所以数组根本没有 push 方法。它在栈上(B 错);mut 只解决「能不能改」,解决不了「装不下」(C 错)。要动态增长请换 Vec。
QUIZ 2
User::new(...) 与 u.greet() 的本质区别是?Rust 没有内置构造函数,new 只是社区惯例命名的关联函数(无 self,用 :: 调)。greet 定义了 &self,所以用 . 调用且自动借用实例——方向与 C 说反了。
CHAPTER 05 · 所有权与类型系统
所有权与 Move
一句话总览:每个值有且只有一个所有者;赋值、传参默认是移动(move)而非拷贝——旧变量立即作废;所有者离开作用域时值被自动
drop。这三条规则就是 Rust 不需要 GC 的全部秘密。🏠
生活化类比
堆上的数据是一栋房子,所有权是房产证:证上永远只有一个名字。
堆上的数据是一栋房子,所有权是房产证:证上永远只有一个名字。
let s2 = s1; 是过户——证改成 s2 的名字,s1 手里的钥匙当场作废;绝不是复制一把钥匙给两个人(否则两人各退一次房 = 双重释放)。整数这类栈上小值像现金:递给你一张等额的,我兜里还有(Copy 类型)。类比边界:clone() 是真金白银盖一栋一模一样的新房(深拷贝,有成本),和过户完全是两回事。5.1 三条规则(背下来)
- ① 每个值都有一个所有者(owner)变量;
- ② 同一时刻只能有一个所有者;
- ③ 所有者离开作用域,值被自动释放(调用
drop,无需 free/GC)。
5.2 move:String 的过户现场
move.rs
let s1 = String::from("hi"); // s1 拥有堆上的 "hi"
let s2 = s1; // move!所有权过户给 s2,s1 作废
// println!("{}", s1); // ❌ E0382: borrow of moved value `s1`
let a = 5;
let b = a; // i32 是 Copy 类型:按位复制,a 依然可用
println!("{} {}", a, b); // ✓ 栈上定长小值没有「过户」问题
let s3 = s2.clone(); // 显式深拷贝:堆数据复制一份,s2、s3 各自拥有move 前后:栈上的「遥控器」与堆上的「电视」
move 的本质:复制「遥控器」、作废旧遥控器,保证电视只被退货一次。
HANDS-ON DEMO
所有权过户模拟器
按顺序点按钮,亲历「创建 → move → 试图用旧变量 → 离开作用域」全过程,观察房产证(所有权)在谁手里。
5.3 函数传参也会过户
fn_move.rs
fn eat(s: String) { // 参数拿到所有权
println!("{}", s);
} // s 在这里 drop,堆内存释放
let meal = String::from("pizza");
eat(meal); // meal 过户进函数
// println!("{}", meal); // ❌ meal 已作废
fn cook() -> String {
String::from("noodle") // 返回值把所有权「递出来」给调用者
}
let dinner = cook(); // dinner 成为新所有者「传个参就把变量弄没了」显然不方便——所以下一章的借用才是日常主力:把东西借出去用,证还在你手里。
⚠ 高频陷阱:move 之后还用旧变量
let s2 = s1; println!("{}", s1); → 编译错误 E0382(borrow of moved value)。新手常想「加个 mut 是不是就行」——不行,这不是可变性问题。正确姿势:只是想读就借 &s1(见第 6 章);确实需要两份数据才 clone();或者调整函数设计,把所有权 return 回来。✓ 记忆锚点
「一值一主,出域即 drop;赋值传参皆过户,栈上 Copy 是例外。」5.4 随堂自测
QUIZ 1
let s1 = String::from("hi"); let s2 = s1; println!("{}", s1); 会发生什么?String 赋值是 move,s1 当场作废,编译器直接拒绝再次使用——错误根本活不到运行时(B 错)。共享而不转移所有权要用引用 &s1;D 的「悄悄变空」在 Rust 里不存在。
QUIZ 2
为什么
let b = a; 之后,i32 的 a 还能继续用,而 String 的 s1 不行?Copy 是显式标记的 trait:纯栈上定长数据(整数、bool、char、纯 Copy 元组)复制无成本、无堆所有权,所以赋值即复制。String 管理堆内存,复制指针会造成双重释放,只能 move。C 把栈堆说反了;clone 是显式深拷贝,不存在「自动 clone」。
CHAPTER 06 · 所有权与类型系统
引用、借用与生命周期
一句话总览:借用 = 不转移所有权的使用权:同一时刻要么任意多个只读引用
&T,要么恰好一个可写引用 &mut T,二者不能共存;且引用绝不能活得比所有者久。全部在编译期检查,运行时零开销。📚
生活化类比
数据是一本馆藏孤本,所有者是图书馆。
数据是一本馆藏孤本,所有者是图书馆。
&T 是阅览证:可以同时发给无数人,大家只能看不能改。&mut T 是独家修订授权:同一时间只发一份,而且修订期间所有阅览证暂停——否则有人正读第 3 页、另一个人把第 3 页撕了重写(数据竞争/迭代器失效)。图书馆倒闭(所有者 drop)前,必须收回所有证(禁止悬垂引用)。类比边界:现实图书馆靠管理员现场盯着,Rust 在编译期就把整个借阅时间表算清楚了,运行时没有任何检查开销。6.1 只读借用:日常主力
borrow.rs
fn char_count(s: &String) -> usize { // 参数是引用:借来看看,不拿走
s.chars().count()
}
let book = String::from("rust 宝典");
let n = char_count(&book); // & 创建引用(借出)
println!("{} 有 {} 个字符", book, n); // ✓ book 所有权还在,继续用
let r1 = &book;
let r2 = &book; // ✓ 只读引用想开几个开几个
println!("{} {}", r1, r2);6.2 可变借用:独占改写权
mut_borrow.rs
let mut s = String::from("hi");
let m = &mut s; // ✓ 唯一的可变引用
m.push_str("!"); // 通过引用修改原数据
// let m2 = &mut s; // ❌ E0499:同一时刻只能有一个 &mut
// let r = &s; // ❌ E0502:m 还活着时不能再借只读引用
println!("{}", m); // m 的最后一次使用 → 借用在此结束(NLL)
let r = &s; // ✓ 现在可以借只读了:m 已「用完即还」
println!("{}", r);NLL(非词法生命周期):借用的有效期到「最后一次使用」为止,不是到花括号结束——所以「先读完再改」的直觉写法大多能编过。
借用规则:读写不共存
「多读 XOR 单写」一条规则,同时消灭了迭代器失效和数据竞争两类经典 bug。
6.3 生命周期:给引用标「保质期关系」
lifetime.rs
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
// 'a 读作「tick a」:声明返回值活得不能比 x、y 中任何一个久
// 因为返回的可能是 x 也可能是 y,编译器需要这条约束才敢放行
let a = String::from("long string");
let result;
{
let b = String::from("hi");
// result = longest(&a, &b); // ❌ b 出这个花括号就没了
} // 若允许,result 将指向已释放的 b
// println!("{}", result); // 悬垂引用被编译期拦下绝大多数场景编译器能自动推导(生命周期省略规则),只有「多个引用进、一个引用出」这类关系不明确时才需要手写 'a。标注不改变任何引用的实际寿命,只是把约束告诉编译器。
⚠ 高频陷阱:引用还在用,就急着改数据
let r = &s; s.push_str("!"); println!("{}", r); → E0502。push 可能触发堆扩容搬家,r 会变成指向旧地址的悬垂指针——编译器禁止的正是这个。正确姿势:把 r 的最后一次使用挪到修改之前(NLL 会自动还证);或先改完再借。✓ 记忆锚点
「读可共享,写必独占;读写不共存,引用不过主。」6.4 随堂自测
QUIZ 1
let r1 = &s; let m = &mut s; println!("{}", r1);(s 是 mut String)结果是?r1 在 println 处还要用,说明它的借用在 &mut s 创建时仍然活跃 → 违反「读写不共存」。若删掉最后的 println(r1 创建后不再用),NLL 会让 r1 提前结束,代码就能编过——关键看「最后一次使用」的位置。
QUIZ 2
生命周期标注
'a 的真实作用是?标注是「声明约束」而非「施加魔法」:编译器用它验证返回引用不会比来源活得久。它不能延长寿命(B),不改变分配位置(C),更不是运行时的引用计数(D)——生命周期是纯编译期概念。
CHAPTER 07 · 所有权与类型系统
字符串与切片
一句话总览:
String 是自己拥有、可增长的堆上 UTF-8 串;&str 是借来的一段只读视图。Rust 字符串禁止整数索引——UTF-8 字符变长,「第 n 个字符」无法 O(1) 定位,干脆不给你歧义的机会。📓
生活化类比
String 是你自己的笔记本:可以续页、涂改、整本送人(move)。&str 是一张透明取景片:盖在任何笔记本的某几页上,只能透过它看,而且取景框不能框住半个字(必须落在字符边界)。字面量 "hi" 是印在程序里的「公共展板」,天生就是 &str。类比边界:JS 字符串按 UTF-16 索引,emoji 会占两格还悄悄切开;Rust 直接禁止索引,逼你显式选「按字节还是按字符」。7.1 两种字符串的分工与互转
strings.rs
let mut owned = String::from("你好"); // String:堆上、可变长、有所有权
owned.push_str(",Rust"); // 追加(需要 mut)
let view: &str = &owned; // String → &str:整体借用(自动解引用)
let part: &str = &owned[0..6]; // 切片视图:"你好"(两个汉字各 3 字节)
let lit: &str = "字面量"; // 字面量类型就是 &str('static)
let copy: String = lit.to_string(); // &str → String:复制一份归自己
fn greet(name: &str) { println!("hi {}", name); }
greet("小豆"); // ✓ 直接传字面量
greet(&owned); // ✓ &String 自动转成 &str —— 所以参数首选 &strString 的三件套与 &str 的取景框
len 是字节数不是字符数;&str = 指针 + 长度的「取景框」,这就是它零拷贝的原因。
7.2 想「取第 n 个」?先说清按什么数
index.rs
let s = String::from("你好Rust");
// let c = s[0]; // ❌ 编译错误:String 不支持整数索引
let third = s.chars().nth(2); // ✓ 按字符数:Some('R'),O(n) 明码标价
let b0 = s.as_bytes()[0]; // ✓ 按字节数:228("你"的第一个 UTF-8 字节)
for (i, c) in s.char_indices() { // 需要「字节位置 + 字符」时用这个
println!("字节偏移 {} : {}", i, c);
}
println!("{}", s.len()); // 10:字节数!不是 6 个字符⚠ 高频陷阱:按 JS 直觉切中文字符串
&s[0..2] 想取「你」→ 运行时 panic:byte index 2 is not a char boundary(一个汉字 3 字节,2 切在字中间)。这类错误编译器查不出(下标是运行时值)。正确姿势:按字符处理用 chars();要截取前 n 个字符用 s.chars().take(n).collect::<String>()。✓ 记忆锚点
「存数据用 String,传参数用 &str;len 数字节,chars 数字符。」7.3 随堂自测
QUIZ 1
Rust 为什么禁止
s[0] 这样索引字符串?按字节索引可能切出半个字符,按字符索引需要 O(n) 扫描——Rust 拒绝隐藏这两种歧义与成本,让你显式选 as_bytes()[i] 或 chars().nth(i)。堆完全支持随机访问(A 错),这是设计决定而非未完成(C 错)。
QUIZ 2
fn greet(name: &str) 这样的参数,能接收哪些实参?deref 强制转换让 &String 自动变 &str,所以 &str 是「最大公约数」参数类型:谁的字符串都能借给它看,且不夺走所有权。这正是「函数参数首选 &str」的原因。
CHAPTER 08 · 所有权与类型系统
枚举、Option 与模式匹配
一句话总览:Rust 的 enum 是能携带数据的标签联合;空值用
Option<T> 表达(Some 有 / None 无),配合穷尽检查的 match——漏处理一种情况,编译器直接亮红灯。JS 的「undefined is not a function」这类事故在类型层面就被消灭了。📦
生活化类比
Option<T> 是一个快递盒:Some(东西) 盒里有货,None 是空盒。铁律:用东西前必须拆盒验视(match / if let),不能把盒子直接当东西使——JS 的 null 事故正是「没拆盒就把盒子当手机用」。enum 则是多形态快递单:「运输中(带坐标)」「已签收(带签收人)」,每种形态自带不同的附加数据。类比边界:TS 的联合类型靠你自觉收窄,Rust 的 match 编译期强制穷尽,少写一个分支都不放行。8.1 带数据的枚举
message.rs
enum Message {
Quit, // 形态1:不带数据
Move { x: i32, y: i32 }, // 形态2:带命名字段(像内嵌 struct)
Write(String), // 形态3:带一个 String
}
fn handle(m: Message) {
match m { // match 按形态拆解,还能顺手绑定内部数据
Message::Quit => println!("退出"),
Message::Move { x, y } => println!("移到 ({}, {})", x, y),
Message::Write(text) => println!("内容: {}", text),
} // 三种形态全覆盖,缺一即编译错误
}8.2 Option:把「可能没有」写进类型里
option.rs
fn find_user(id: u32) -> Option<String> { // 返回值大声宣告:可能查不到
if id == 1 { Some(String::from("小豆")) } else { None }
}
match find_user(2) {
Some(name) => println!("找到 {}", name),
None => println!("查无此人"), // 必须处理,不处理编不过
}
if let Some(name) = find_user(1) { // 只关心一种形态时的简写
println!("{}", name);
}
let n = find_user(9).unwrap_or(String::from("游客")); // 给兜底值
let first = vec![1, 2].get(10); // get 返回 Option,不 panic8.3 拆盒工具速查
| 工具 | 行为 | 适用场景 |
|---|---|---|
match | 穷尽所有形态,可绑定数据 | 正式业务逻辑(首选) |
if let | 只匹配一种形态,其余忽略 | 「有就处理、没有拉倒」 |
unwrap_or(默认值) | None 时用兜底值 | 有合理默认值 |
? 运算符 | None/Err 提前返回(第 10 章) | 向调用者传播「没有」 |
unwrap() | None 时直接 panic | 仅限测试/原型/逻辑上不可能为 None |
null 的事故路径 vs Option 的强制拆盒
Option<T> 和 T 是不同类型:想拿到 T 必须经过 match——「忘了判空」从运行时事故变成编译错误。
⚠ 高频陷阱:unwrap() 一路梭哈
为了让编译器闭嘴,处处 .unwrap() → 线上遇到一个 None 就 panic 崩溃,等于把编译期保护亲手拆掉、退化回 null 时代。正确姿势:业务代码用 match / if let / unwrap_or / ?;unwrap 只留给测试和「逻辑上可证明不可能是 None」的地方,并加注释说明理由。✓ 记忆锚点
「世上没有 null,只有没拆的盒;match 要穷尽,漏支就红灯。」8.4 随堂自测
QUIZ 1
对
Option<i32> 做 match 时只写了 Some(x) 分支,会怎样?match 的穷尽性在编译期检查,漏掉 None 直接报 non-exhaustive patterns。「只想处理 Some」应该用 if let(它允许忽略其余情况),或补 None => {} / _ => {}。Rust 不会替你编默认值。
QUIZ 2
if let Some(x) = opt { ... } 相比完整 match 的定位是?if let 就是「单分支 match」的简写,编译产物与 match 等价(A 错);它对不匹配的情况什么都不做(C 错)。需要处理多种形态时还是用 match,让穷尽检查替你站岗。
CHAPTER 09 · 抽象与工程化
集合:Vec 与 HashMap
一句话总览:
Vec<T> 是可增长的堆上数组,靠 len(元素数)/ cap(座位数)双计数工作,坐满就整体搬家翻倍扩容;HashMap 管键值对。集合拥有其元素,访问越界问题用返回 Option 的 get 最稳。🎬
生活化类比
Vec 是一排影厅座位:len = 已入座人数,cap = 已建好的座位数。人坐满了再来人,不是原地挤一挤,而是包下两倍大的新影厅、全员搬过去、拆掉旧厅(重新分配 + 拷贝 + 释放)。所以你手里「旧厅 3 号座」的纸条(引用)会作废——这正是第 6 章借用规则要拦的事。类比边界:JS 数组随便 push,因为对象引用由 GC 追踪、搬家也不失效;Rust 引用是裸地址,搬家必须靠编译期检查保护。
Vec 是一排影厅座位:len = 已入座人数,cap = 已建好的座位数。人坐满了再来人,不是原地挤一挤,而是包下两倍大的新影厅、全员搬过去、拆掉旧厅(重新分配 + 拷贝 + 释放)。所以你手里「旧厅 3 号座」的纸条(引用)会作废——这正是第 6 章借用规则要拦的事。类比边界:JS 数组随便 push,因为对象引用由 GC 追踪、搬家也不失效;Rust 引用是裸地址,搬家必须靠编译期检查保护。
9.1 Vec 基本操作
vec.rs
let mut v: Vec<i32> = Vec::new(); // 空 Vec,尚未分配堆内存
let mut w = vec![1, 2, 3]; // vec! 宏:带初始值的快捷构造
v.push(10); // 追加(要 mut)
let last = v.pop(); // 弹出末尾:Option<i32>(空时 None)
let a = w[0]; // 索引访问:越界直接 panic!
let b = w.get(100); // get 访问:越界返回 None,不崩
if let Some(x) = w.get(1) { println!("{}", x); }
println!("len={} cap={}", w.len(), w.capacity()); // 元素数 vs 座位数HANDS-ON DEMO
Vec 扩容搬家模拟器
连续 push 观察 len 与 cap:座位坐满的那一刻,Vec 会整体搬进两倍大的新影厅。留意日志里「旧引用为什么作废」。
9.2 HashMap 与 entry 惯用法
map.rs
use std::collections::HashMap; // 不在 prelude,要显式 use
let mut scores: HashMap<String, i32> = HashMap::new();
scores.insert(String::from("小豆"), 90); // insert 移交键值的所有权
let s = scores.get("小豆"); // Option<&i32>:查无此键返回 None
*scores.entry(String::from("阿花")).or_insert(0) += 1;
// entry 惯用法:「没有就插默认值,有就拿到可变引用」——词频统计一行搞定
for (name, score) in &scores { // 遍历借用,不夺走 map 所有权
println!("{}: {}", name, score);
}| 操作 | 越界 / 缺键时 | 建议 |
|---|---|---|
v[i] / map[&k] | panic(Vec 越界 / 键不存在) | 下标已被证明合法时用 |
v.get(i) / map.get(&k) | 返回 None | 外部输入、不确定场景首选 |
map.entry(k).or_insert(v) | 缺键则插入默认值 | 计数、分组、缓存 |
⚠ 高频陷阱:握着元素引用还 push
let first = &v[0]; v.push(4); println!("{}", first); → E0502 编译错误。push 可能触发扩容搬家,first 将指向已拆除的旧影厅。正确姿势:先用完 first 再 push(NLL 自动还证);确实要长期共存就存索引 let i = 0; 或 clone 一份值。✓ 记忆锚点
「len 是人,cap 是座;坐满搬家翻一倍;怕越界用 get,缺键计数用 entry。」9.3 随堂自测
QUIZ 1
对只有 3 个元素的 Vec,
v.get(100) 与 v[100] 分别会怎样?[] 走 Index trait,契约是「必须给出元素」,给不出就 panic;get 的签名是 Option<&T>,把「可能没有」写进类型让你处理。Rust 不会编造 0 当默认值(D 错)。
QUIZ 2
为什么持有
&v[0] 期间调用 v.push(...) 会被编译器拒绝?扩容 = 新分配 + 拷贝 + 释放旧块,&v[0] 指向的旧地址随即失效。这是「读写不共存」规则防住的真实事故,不是误报;unsafe 只会关掉保护而非解决问题。先用完引用再 push 即可(C 的「永久只读」不存在)。
CHAPTER 10 · 抽象与工程化
错误处理:panic! 与 Result
一句话总览:Rust 把失败分成两类:不可恢复的用 panic!(程序缺陷,直接崩),可恢复的用 Result<T, E>(把失败当普通值返回);
? 运算符把「检查错误 → 向上传播」的样板代码压缩成一个字符。🍜
生活化类比
panic 是后厨着火:整家店停止营业(线程终止),因为继续做饭只会更糟。
panic 是后厨着火:整家店停止营业(线程终止),因为继续做饭只会更糟。
Result 是「今日售罄」通知单:菜做不了是正常经营情况,服务员(调用方)拿着单子决定换菜、退钱还是上报店长。? 就是服务员的标准动作:看到通知单立刻转交店长(提前 return Err),菜正常就继续端。类比边界:Go 的 if err != nil { return err } 就是 ? 的手动展开——Rust 只是把这三行折叠成了一个字符,机制完全同源。10.1 两类失败,两种通道
two_kinds.rs
panic!("数组契约被破坏"); // 不可恢复:打印信息、展开栈、线程终止
let v = vec![1, 2];
// let x = v[99]; // 越界 → 内部就是 panic(这是 bug,不是业务失败)
use std::fs::File;
let f = File::open("config.toml"); // 可恢复:返回 Result<File, io::Error>
match f {
Ok(file) => println!("打开成功 {:?}", file),
Err(e) => println!("打开失败: {}(可以创建默认配置兜底)", e),
}10.2 ? 运算符:错误传播的高速公路
question.rs
use std::io::{self, Read};
use std::fs::File;
fn read_config(path: &str) -> Result<String, io::Error> {
let mut file = File::open(path)?; // Ok → 拆出 File 继续;Err → 立即 return Err
let mut text = String::new();
file.read_to_string(&mut text)?; // 同上,读失败也原样上抛
Ok(text) // 一切顺利,把值装进 Ok 交出
}
// ? 完全等价于:match File::open(path) { Ok(f) => f, Err(e) => return Err(e.into()) }
fn main() {
let cfg = read_config("app.toml").unwrap_or_default(); // 边界处统一兜底
println!("配置长度 {}", cfg.len());
}? 在每个调用点的分流逻辑
? = 「成功拆包继续走,失败原样往上抛」——把 Go 的三行 if err != nil 折叠成一个字符。
⚠ 高频陷阱:在返回 () 的函数里用 ?
在普通 fn main() 或任何返回 () 的函数里写 File::open(p)? → 编译错误「the ? operator can only be used in a function that returns Result/Option」。正确姿势:把函数签名改成 -> Result<..., ...>(main 也可以),或在原地 match / unwrap_or 处理掉。另外:库里滥用 unwrap 等于替调用者决定「出错就崩」,库代码应返回 Result 让调用者选择。✓ 记忆锚点
「程序缺陷 panic,业务失败 Result;问号一挂,有错上传、无错拆包。」10.3 随堂自测
QUIZ 1
? 遇到 Err(e) 时的行为是?? 是控制流语法糖:Err 分支等价于 return Err(e.into()),把决定权交给调用者——不 panic、不吞错、不重试。这正是「错误是值」哲学的体现:失败沿着返回值通道逐层上传。
QUIZ 2
「配置文件可能不存在,不存在就用默认配置」——这个需求应该走哪条通道?
文件不存在是可预期、可恢复的业务情况,用 Result 把 io::Error(含原因)带出来,由调用方决定兜底策略。panic 只留给「继续运行必然更糟」的程序缺陷;Option 会丢掉错误原因,排障时两眼一抹黑。
CHAPTER 11 · 抽象与工程化
泛型与 Trait
一句话总览:泛型让逻辑只写一遍,编译期为每个具体类型展开专属机器码(单态化,零运行时开销);trait 是行为契约——像 TS interface,但能带默认实现,还能给已有类型补挂新能力,这是继承做不到的。
🥮
生活化类比
泛型是月饼模具:模具刻一次,编译时给五仁、豆沙各开一条专属生产线(单态化)——运行时每条线都是全速直产,没有「先问是什么馅」的开销。TS 泛型只是出厂前贴的质检标签,打包(编译成 JS)后标签撕掉;Rust 是真开了多条线。trait 是 USB 接口标准:任何设备都能声明「我支持 USB」(
泛型是月饼模具:模具刻一次,编译时给五仁、豆沙各开一条专属生产线(单态化)——运行时每条线都是全速直产,没有「先问是什么馅」的开销。TS 泛型只是出厂前贴的质检标签,打包(编译成 JS)后标签撕掉;Rust 是真开了多条线。trait 是 USB 接口标准:任何设备都能声明「我支持 USB」(
impl Trait for Type),连标准发布之后出厂的老设备也能补挂适配。类比边界:生产线开多了厂房会变大(二进制膨胀);想只留一条线、运行时再问类型,就换 dyn Trait(动态分发,有一次查表跳转的代价)。11.1 泛型 + trait bound:能力先说清
generic.rs
fn largest<T: PartialOrd>(list: &[T]) -> &T { // T 必须「能比大小」
let mut max = &list[0];
for item in list {
if item > max { max = item; } // 没有 PartialOrd 约束,> 都写不了
}
max
}
largest(&[3, 9, 2]); // 编译器生成 largest::<i32> 专用版本
largest(&["a", "z", "m"]); // 再生成 largest::<&str> 版本 —— 这就是单态化11.2 trait:定义契约、补挂能力
trait.rs
trait Summary {
fn title(&self) -> String; // 必须实现的方法
fn summarize(&self) -> String { // 默认实现:可直接用可覆盖
format!("{}……(阅读全文)", self.title())
}
}
struct Article { heading: String }
impl Summary for Article {
fn title(&self) -> String { self.heading.clone() }
}
impl Summary for String { // 给标准库类型补挂能力!
fn title(&self) -> String { self.clone() }
}
fn notify(item: &impl Summary) { // 静态分发:编译期定死类型
println!("{}", item.summarize());
}
fn notify_dyn(item: &dyn Summary) { // 动态分发:运行时查 vtable
println!("{}", item.summarize());
}单态化(impl Trait)vs 动态分发(dyn Trait)
impl Trait 用体积换速度(编译期展开),dyn Trait 用一次间接跳转换灵活(运行期查表)。
| 常用 trait | 含义 | 备注 |
|---|---|---|
Debug / Display | {:?} 调试打印 / {} 用户打印 | #[derive(Debug)] 一行自动生成 |
Clone / Copy | 显式深拷贝 / 赋值即按位复制 | Copy 只能给纯栈上小类型 |
Default | 提供默认值 | 配合 ..Default::default() |
PartialEq / PartialOrd | 判等 / 比大小 | 泛型里用 == 和 > 的前提 |
Iterator | 可迭代 | 第 14 章主角 |
⚠ 高频陷阱:方法明明实现了却「找不到」
调用 "x".parse::<i32>() 或某 trait 方法时报 no method named ... found,但文档明明有 → 十有八九是 trait 没 use 进作用域(如 use std::io::Read; 之后才能调 read_to_string)。另一坑是孤儿规则:不能给「别人的类型」实现「别人的 trait」,trait 和类型至少有一个得是你 crate 里的。✓ 记忆锚点
「泛型开产线,trait 定标准;impl 静态快,dyn 动态活;方法找不到,先查 use。」11.3 随堂自测
QUIZ 1
Rust 泛型与 TS 泛型在编译产物上的本质区别是?
单态化 = 编译期把 largest<T> 展开成 largest_i32、largest_str 等真实函数,可内联、零运行时开销,代价是体积。TS 的类型只存在于编译检查阶段,产物里完全消失——这是「标签 vs 生产线」的差别。
QUIZ 2
类型明明
impl Read for MyType 了,调用 obj.read_to_string(...) 却报 no method found,最可能的原因是?trait 方法只有当 trait 本身在作用域内才可见——补一行 use std::io::Read; 即可。编译器通常会在报错里提示「trait ... is implemented but not in scope」。impl 位置、文件都不影响(B 错),trait 方法的可见性跟随 trait(A/D 错)。
CHAPTER 12 · 抽象与工程化
模块、Crate 与测试
一句话总览:crate 是编译单位,mod 是命名空间树,一切默认私有、公开靠
pub;测试是一等公民——函数上贴 #[test],cargo test 全搞定,不用装任何测试框架。🏢
生活化类比
crate 是一家公司,mod 是部门,pub 是对外开放窗口:没开窗口的部门,外人一律进不去(默认私有)。
crate 是一家公司,mod 是部门,pub 是对外开放窗口:没开窗口的部门,外人一律进不去(默认私有)。
use 是把内部长号存成手机快捷联系人。mod utils; 只是挂部门铭牌——它宣告「存在 utils 部门」,办公室(utils.rs 文件)得真的盖出来,光挂牌不盖房编译器就报「找不到办公室」。类比边界:和 npm 包不同,Rust 里子部门能看父部门的内部资料(子模块可访问祖先的私有项),反过来不行。12.1 模块树与路径
src/lib.rs
mod front_of_house { // 私有模块:外面看不见
pub mod hosting { // pub 才对外开窗口
pub fn add_to_waitlist() {} // 函数也要 pub,层层都要开
fn seat_at_table() {} // 私有:只有 hosting 内部能用
}
}
pub use crate::front_of_house::hosting; // 重导出:给外部一条短路径
// 外部调用:my_crate::hosting::add_to_waitlist();
// 路径三件套:crate:: 从根出发 / super:: 上一级 / self:: 当前模块可见性:每一层都要开窗口
路径上任何一层没 pub,整条路就不通——「模块 pub 了函数忘 pub」是新手第一大编译错误来源。
12.2 文件组织与依赖
项目结构 + Cargo.toml
// src/main.rs ← 二进制 crate 根(cargo run 跑它)
// src/lib.rs ← 库 crate 根(可选,逻辑放这里便于测试/复用)
// src/utils.rs ← main.rs 里写 `mod utils;` 就挂上这个文件
// src/net/mod.rs ← 目录模块:net/ 目录 + mod.rs(或新版 net.rs + net/)
// Cargo.toml —— 相当于 package.json
// [dependencies]
// serde = { version = "1", features = ["derive"] } // 去 crates.io 找包
// tokio = { version = "1", features = ["full"] }12.3 测试:内置,不用装框架
src/lib.rs(测试模块)
pub fn add(a: i32, b: i32) -> i32 { a + b }
#[cfg(test)] // 只在 cargo test 时编译,不进产物
mod tests {
use super::*; // 把父模块(被测代码)拉进来
#[test] // 贴上这个标签就是测试用例
fn adds_two() {
assert_eq!(add(2, 2), 4); // 断言相等,失败打印左右值
}
#[test]
#[should_panic] // 期望 panic 的测试(如越界契约)
fn bad_index() { let v = vec![1]; let _ = v[9]; }
}
// 终端:cargo test 跑全部;cargo test adds 按名字过滤⚠ 高频陷阱:光挂牌不盖房
写了 mod utils; 却没建文件 → 编译错误 file not found for module utils。另一个高频坑:模块 pub 了、里面的函数忘 pub → 外部报「private function」。正确姿势:mod 声明与 src/utils.rs(或 utils/mod.rs)成对出现;对外路径逐层检查 pub。✓ 记忆锚点
「默认全私有,层层要 pub;mod 挂牌,文件盖房;测试贴标签,cargo test 上场。」12.4 随堂自测
QUIZ 1
关于模块可见性,下列说法正确的是?
Rust 的隐私是「向外」的:孩子能翻家长的抽屉(子模块访问祖先私有项),家长不能翻孩子的。pub 不传染,路径每一层都要显式公开——A/C/D 都是常见误解。
QUIZ 2
#[cfg(test)] 的作用是?cfg 是编译期开关:test 配置未开启时整个模块不参与编译,所以测试代码不会膨胀发布二进制。它是「编译期裁剪」而非「运行时跳过」(C 错),与性能优化、bug 标记无关。
CHAPTER 13 · 进阶与实战
智能指针:Box / Rc / RefCell
一句话总览:智能指针 = 带着元数据与职责的指针:
Box 独占堆数据、Rc 用引用计数共享所有权、RefCell 把借用检查搬到运行时(内部可变性);多线程场景对应换成 Arc + Mutex。🔑
生活化类比
Box:大件家具放租的仓库(堆),兜里只揣一张取货单(栈上指针)。Rc:多人合骑的共享单车,每人拿一把钥匙(Rc::clone 计数 +1),最后一个人还钥匙时车才报废(计数归零才 drop)。RefCell:无人值守自习室——门口没有管理员(编译期不查),但屋里有摄像头(运行时查),谁敢在有人阅读时改写白板,当场报警(panic)。类比边界:Rc 的计数不是原子操作,只限单线程;跨线程共享要用 Arc(原子计数)+ Mutex(排队改写)。另外 Rc 互相引用会形成「钥匙圈死循环」,计数永不归零 → 内存泄漏,需要 Weak 弱引用破环。13.1 Box:递归类型的救星
list.rs
enum List {
Cons(i32, Box<List>), // Box 断开无限递归:指针大小固定(8 字节)
Nil,
}
// 若写成 Cons(i32, List),编译器算大小会无限展开:List 含 List 含 List…
let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
let big = Box::new([0u8; 1_000_000]); // 大数组放堆上,栈只留指针13.2 Rc + RefCell:共享且可改
shared.rs
use std::rc::Rc;
use std::cell::RefCell;
let shared = Rc::new(RefCell::new(vec![1, 2])); // 经典组合拳
let owner2 = Rc::clone(&shared); // 计数 +1(不是深拷贝数据!)
println!("{}", Rc::strong_count(&shared)); // 2
shared.borrow_mut().push(3); // 运行时申请「独家改写权」
println!("{:?}", owner2.borrow()); // [1, 2, 3] 两个所有者看到同一份数据
// let a = shared.borrow_mut();
// let b = shared.borrow_mut(); // ⚠ 编译能过!运行时 panic:已存在可变借用Rc 引用计数的一生
Rc 把「谁负责释放」从编译期唯一所有者放宽为「最后一个离开的人关灯」——代价是运行时计数与循环泄漏风险。
| 指针 | 所有权 | 可变性检查 | 线程 | 典型场景 |
|---|---|---|---|---|
Box<T> | 独占 | 编译期 | 可 Send | 递归类型、大数据上堆、dyn 装箱 |
Rc<T> | 共享(计数) | —(只读) | 仅单线程 | 多个结构共享同一份只读数据 |
Rc<RefCell<T>> | 共享 | 运行时 | 仅单线程 | 共享且要改:树节点、观察者 |
Arc<Mutex<T>> | 共享(原子计数) | 锁排队 | 多线程 | 跨线程共享可变状态(第 15 章) |
⚠ 高频陷阱:RefCell 把编译错误换成运行时炸弹
连续两次 borrow_mut() 编译畅通无阻,一运行就 panic: already mutably borrowed——RefCell 没有取消规则,只是把检查推迟到运行时。正确姿势:让借用的作用域尽量短(用花括号包住 borrow),或先 clone 出值再改;能不用内部可变性就不用,它是逃生舱不是日常工具。✓ 记忆锚点
「Box 独占上堆,Rc 计数共享,RefCell 运行时站岗;跨线程换 Arc,改数据加 Mutex。」13.3 随堂自测
QUIZ 1
递归枚举
enum List { Cons(i32, List), Nil } 编译报「recursive type has infinite size」,标准解法是?编译器要在编译期算出类型大小,直接内嵌自身会无限展开。Box 是指针(固定 8 字节),把「下一节点」放到堆上,大小立即可算。这与 Clone、字段宽度、可变性都无关。
QUIZ 2
RefCell 的「读写不共存」规则在什么时候检查、违反时什么后果?
RefCell 的意义就是绕过编译期借用检查(否则 Rc 共享的数据没法改),改为运行时记账:borrow/borrow_mut 时验证,违规 panic 而非返回 Err(try_borrow 才返回 Result)。规则仍在,只是执法时间推迟了。
CHAPTER 14 · 进阶与实战
闭包与迭代器
一句话总览:迭代器是惰性流水线:map/filter 只是「画图纸」(适配器),collect/sum 等消费者出现才开工,且整条链一趟跑完、不产生中间数组;闭包按捕获方式自动归入 Fn / FnMut / FnOnce 三档。
🏗️
生活化类比
迭代器链是流水线订单:
迭代器链是流水线订单:
filter、map 是写在订单上的工序(图纸),collect() 是「开工」按钮。只写订单不按钮,一台机器都不转(惰性)。而且开工后每个原料一口气过完全部工序,不像 JS 数组那样每个 .map 都立刻生成一个新数组、再被下一个 .filter 重新扫一遍。类比边界:迭代器的元素通常只能消费一次(尤其 into_iter 会 move 元素),想反复用就先 collect 成 Vec;JS 数组可以随便重复遍历。14.1 闭包:会记事的匿名函数
closure.rs
let add = |a: i32, b: i32| a + b; // 参数用 | | 包住,类型常可省略
add(2, 3);
let base = 10;
let add_base = |x| x + base; // 捕获环境变量 base(Fn:只读借用)
let mut count = 0;
let mut tick = || { count += 1; }; // FnMut:可变借用环境
tick();
let name = String::from("小豆");
let greet = move || println!("{}", name); // move:把 name 所有权搬进闭包
// println!("{}", name); // ❌ name 已被 move 进闭包
// 线程 spawn 的闭包几乎总要 move(第 15 章)14.2 迭代器:图纸与开工
iter.rs
let v = vec![1, 2, 3, 4, 5];
let blueprint = v.iter().filter(|x| *x % 2 == 1).map(|x| x * 10);
// ⚠ 此刻什么都没发生!只是把工序记在图纸上(惰性)
let out: Vec<i32> = blueprint.collect(); // 开工![10, 30, 50]
let total: i32 = v.iter().sum(); // sum 也是消费者:15
let n = v.iter().filter(|x| **x > 2).count(); // count:3HANDS-ON DEMO
惰性流水线开工模拟器
先添加工序(适配器),观察元素纹丝不动;再按 collect() 开工,看每个元素一口气穿过整条链。工序添加顺序不同,结果也不同。
| 方法 | 产出元素 | 对原集合的影响 |
|---|---|---|
v.iter() | &T 只读引用 | 无,v 还能随便用 |
v.iter_mut() | &mut T 可变引用 | 可原地改元素(v 需 mut) |
v.into_iter() | T 值本身 | v 被 move,之后不能再用 |
| 适配器(惰性) | map / filter / take / skip / zip / enumerate / rev —— 只记图纸 | |
| 消费者(开工) | collect / sum / count / fold / for_each / find / any —— 驱动整条链 | |
⚠ 高频陷阱:画完图纸忘了开工
v.iter().map(|x| println!("{}", x)); → 一行都不打印!map 是惰性的,没有消费者整条链就是废纸(clippy 会警告 unused iterator)。想执行副作用用 for_each 或 for 循环。另一坑:for x in v 等价 into_iter,循环完 v 就没了——想留着 v 就写 for x in &v。✓ 记忆锚点
「适配器画图纸,消费者才开工;iter 借、iter_mut 改、into_iter 搬空。」14.3 随堂自测
QUIZ 1
let it = v.iter().map(|x| x * 2); 执行完这一行,发生了什么?map 是适配器,只把「×2」记进迭代器结构体,不碰任何元素;直到 collect/sum/for 等消费者驱动它才逐个计算。iter() 是借用(D 错),map 也不原地修改(C 错)——这正是它区别于 JS 数组 .map 的地方。
QUIZ 2
for x in v { ... } 循环结束后还想用 v,结果发现编译报错,原因与修法是?for 的语法糖是对 IntoIterator 的调用:直接写 v 即 into_iter,元素被逐个 move 出来,v 随之作废。&v 走 iter()(借只读引用),&mut v 走 iter_mut()。mut 解决不了所有权转移(B 错)。
CHAPTER 15 · 进阶与实战
无畏并发:线程与通道
一句话总览:Rust 把数据竞争变成编译错误:Send/Sync 标记 + 所有权规则让「共享可变状态」只能存在于
Arc<Mutex<T>> 这类保护之下;更推荐的姿势是通道传消息——「不要靠共享内存来通信,要靠通信来共享内存」。👨🍳
生活化类比
多线程是几个厨师共用一间厨房。传统语言:大家直接抢同一口锅,撞了(数据竞争)只能等开业后出事故。Rust:卫生检查员(编译器)开工前就立规矩——食材要么整份递交给某个人(move / 通道),要么放进带锁的柜子(Mutex),拿钥匙才能动。Send = 「这份食材可以搬进别的厨房」;Sync = 「可以让多人同时隔着玻璃看」。类比边界:检查员只防「两人同时改一口锅」(数据竞争),不防死锁——两人各攥着对方要的钥匙互相等,编译器不管,得靠设计。
多线程是几个厨师共用一间厨房。传统语言:大家直接抢同一口锅,撞了(数据竞争)只能等开业后出事故。Rust:卫生检查员(编译器)开工前就立规矩——食材要么整份递交给某个人(move / 通道),要么放进带锁的柜子(Mutex),拿钥匙才能动。Send = 「这份食材可以搬进别的厨房」;Sync = 「可以让多人同时隔着玻璃看」。类比边界:检查员只防「两人同时改一口锅」(数据竞争),不防死锁——两人各攥着对方要的钥匙互相等,编译器不管,得靠设计。
15.1 spawn:闭包几乎总要 move
spawn.rs
use std::thread;
let data = vec![1, 2, 3];
let handle = thread::spawn(move || { // move:把 data 所有权搬进新线程
println!("{:?}", data); // 不 move 会报错:线程可能活得比 data 久
});
// println!("{:?}", data); // ❌ data 已属于新线程
handle.join().unwrap(); // 等子线程收工(不 join 主线程可能先退出)15.2 通道:把数据递过去,而不是抢
channel.rs
use std::sync::mpsc; // multi-producer, single-consumer
use std::thread;
let (tx, rx) = mpsc::channel();
for i in 0..3 {
let txi = tx.clone(); // 多生产者:克隆发送端
thread::spawn(move || {
txi.send(format!("任务{}完成", i)).unwrap(); // send 移交值的所有权
});
}
drop(tx); // 关掉原始发送端,否则 rx 永远等
for msg in rx { // 所有发送端都关闭后,循环自然结束
println!("{}", msg);
}15.3 共享状态:Arc + Mutex 组合拳
shared_state.rs
use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0)); // Arc:跨线程计数;Mutex:排队改写
let mut handles = vec![];
for _ in 0..4 {
let c = Arc::clone(&counter); // 计数 +1,四个线程共享同一把锁
handles.push(thread::spawn(move || {
let mut n = c.lock().unwrap(); // 拿锁;拿不到就等(不会数据竞争)
*n += 1; // 锁守卫离开作用域自动解锁
}));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap()); // 4,稳定无竞态通道:所有权顺着管道流动
通道把并发问题化简为所有权问题:值在管道里流动,任何时刻只有一个主人。
⚠ 高频陷阱:spawn 闭包借用局部变量
thread::spawn(|| println!("{:?}", data)); → E0373「closure may outlive the current function」:新线程可能比当前函数活得久,借用的 data 会悬垂。正确姿势:加 move 搬所有权,或搬 Arc::clone。另记两条:① 忘 join 可能主线程先退、子线程没跑完;② 死锁编译器不防——两把锁按不同顺序拿就会互等,团队约定统一的加锁顺序。✓ 记忆锚点
「能搬走是 Send,能共看是 Sync;跨线程改数 Arc 套 Mutex,不想用锁走通道。」15.4 随堂自测
QUIZ 1
为什么
thread::spawn 的闭包几乎总是要写 move?spawn 要求闭包满足 'static:不能借用可能先死掉的数据。move 把捕获变量的所有权搬进闭包,寿命与线程绑定。不写 move 且闭包不捕获任何局部值时也能编译(C 错);它与性能、加锁无关。
QUIZ 2
「Rust 无畏并发」的准确含义是?
Send/Sync + 借用规则消灭的是「无同步的并发读写」(data race)这一类 UB;死锁(互相等锁)和业务时序问题编译器无法推理。运行时没有检测器(B 错);Arc 共享内存完全合法(D 错)。
CHAPTER 16 · 进阶与实战
async 入门与学习路线
一句话总览:
async fn 返回一个被 poll 才推进的 Future 状态机,.await 之前一行代码都不执行(惰性);Rust 不自带异步运行时,社区标配 tokio 当执行器——这是它与 JS「Promise 一创建就开跑」最大的思维差异。🛵
生活化类比
Future 是外卖订单:调用 async fn 只是拿到订单小票,后厨根本没开火;
Future 是外卖订单:调用 async fn 只是拿到订单小票,后厨根本没开火;
.await 是把小票交给外卖调度员(tokio 执行器),这才开始做菜。等餐期间调度员去派别的单(线程不空等),餐好了骑手按 waker 通知回来取。JS 的 Promise 相反:一调用后厨就开火(eager),await 只是等结果。类比边界:调度员线程是全店共用的——你在 async 里干同步重活(大计算、std 的 sleep)等于霸占调度员,全店订单都卡住;重活要交给 spawn_blocking 或独立线程。16.1 最小可跑的 async
main.rs(依赖 tokio = { version = "1", features = ["full"] })
async fn fetch_data(id: u32) -> String {
tokio::time::sleep(std::time::Duration::from_millis(100)).await; // 模拟 IO
format!("数据{}", id)
}
#[tokio::main] // 宏:搭好执行器,把 main 变成 async 世界入口
async fn main() {
let lazy = fetch_data(1); // ⚠ 此刻什么都没发生,只拿到 Future
println!("{}", lazy.await); // await 才真正执行
let (a, b) = tokio::join!(fetch_data(2), fetch_data(3)); // 并发等两个
println!("{} {}", a, b); // 总耗时 ≈ 100ms 而不是 200ms
}Future 状态机:poll 驱动,waker 唤醒
Future = 惰性状态机 + poll/waker 协议;执行器(tokio)负责「谁就绪就跑谁」,这就是异步高并发的底层。
| 维度 | JS Promise | Rust Future |
|---|---|---|
| 创建即执行? | 是(eager,调用就开跑) | 否(lazy,poll/await 才动) |
| 执行器 | 引擎内置事件循环 | 无内置,需 tokio / async-std 等库 |
| 并发模型 | 单线程事件循环 | 可多线程 work-stealing(tokio 默认) |
| 阻塞重活 | 本来就单线程,都会卡 | 用 spawn_blocking 挪出执行器线程 |
16.2 学习路线与实战方向(面向有编程经验者)
| 阶段 | 目标 | 材料 / 练手 |
|---|---|---|
| ① 1~2 周 | 过完本宝典 + 所有权肌肉记忆 | 官方《The Book》对照读;rustlings 小练习逐个修编译错误 |
| ② 2~4 周 | 写一个真用得上的 CLI 工具 | clap(参数)+ serde(JSON)+ anyhow(错误);如批量重命名、日志统计 |
| ③ 选方向 | 结合已有技术栈变现 | 前端向:wasm-bindgen 把重计算编成 wasm 给网页用;后端向:axum 写 API;硬件向:esp-hal 点灯 ESP32;工具向:付费小工具(Tauri 桌面壳) |
| ④ 持续 | 工程化习惯 | cargo clippy 天天跑;读标准库源码;《Rust API Guidelines》 |
⚠ 高频陷阱:拿了 Future 不 await / 在 async 里干重活
① fetch_data(1); 单独一行 → 什么都不会发生(编译器警告 unused future),JS 直觉「调了就在跑」在这里失效。② 在 async 里调 std::thread::sleep 或跑大计算 → 霸占执行器线程,其他任务全部停摆。正确姿势:异步等待用 tokio::time::sleep;CPU 重活交给 tokio::task::spawn_blocking。✓ 记忆锚点
「async 调用只下单,await 之后才开火;调度员别霸占,重活 blocking 桌上放。」16.3 随堂自测
QUIZ 1
调用
async fn work() 但不加 .await 也不交给执行器,函数体里的代码会执行吗?Rust 的 Future 完全惰性:poll 之前连第一行都不跑(C 描述的「跑到首个 await」是 JS/C# 的 eager 行为)。不 await 只是拿到值没用,编译器给 warning 而非 error(D 错)。这是从 JS 转 Rust 最需要重置的直觉。
QUIZ 2
在 tokio 的 async 任务里执行 3 秒的纯 CPU 密集计算,正确的做法是?
.await 只能在异步暂停点让出控制权,纯计算没有暂停点,会霸占执行器 worker,饿死其他任务。spawn_blocking 把重活挪到专用阻塞线程池。async 不会自动并行化计算(A 错),sleep 分段既丑陋也不解决问题(C 错)。