Rust 学习宝典
CHAPTER 01 · 入门基础

初识 Rust 与 Cargo

一句话总览:Rust = C/C++ 级性能 + 无 GC 的内存安全,秘诀是把安全检查全部搬到编译期——编译器像一个严厉但讲道理的安检员,过了安检的程序几乎不会有内存错误。
🛂
生活化类比
JS/Go 像先放行、出事再处理的车站:空指针、数据竞争等问题在运行时才爆炸(GC 是随时跟着打扫的保洁员)。Rust 像登机前全身安检:借用检查器就是安检门,带危险品(悬垂引用、双重释放)根本登不了机,所以飞行中不需要保洁员(无 GC、零运行时开销)。类比边界:安检只查「危险品」——内存与并发安全;它不保证你的业务逻辑正确,编译通过的程序照样能算错账。

1.1 和你熟悉的语言比一比

维度JS / TSGoC / C++Rust
内存管理GCGC手动 malloc/free所有权,编译期自动插入释放
空值null / undefinednil(可 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:四道关卡全在「运行之前」 main.rs 源代码 语法 + 类型检查 rustc 前端 借用检查器 所有权 / 生命周期 LLVM 优化 生成机器码 运行 无 GC 内存危险 → 编译报错,根本到不了运行时 对照 JS:源码 → 解释器边跑边执行,空引用 / 类型错误要等「跑到那一行」才炸。
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 换盒子
let mut b = 5; b = 6; b : i32 5 → 6 同一块内存,值被覆盖;类型永远是 i32 let x = 5; let x = "six"; x : i32 = 5 旧绑定(已失效) x : &str = "six" 全新绑定,类型可不同 两个独立变量恰好同名,编译器只认最新那个
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 报错)
字符char4 字节 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 遍历一切迭代器
一个分号如何「吞掉」返回值
fn add(a: i32, b: i32) -> i32 { a + b // 无分号 = 尾表达式 产出 i32 ✓ fn add(a: i32, b: i32) -> i32 { a + b; // 分号把值消音了! 产出 () → E0308 类型不匹配 ✗
函数返回的不是「最后执行的东西」,而是「尾表达式的值」——分号一加,尾表达式就没了。
⚠ 高频陷阱:手滑多写一个分号
从 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 ≈ 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 对象)
Rust:字段连续排布,偏移量编译期已知 u : User(栈上) name: String(ptr,len,cap) age: u32 = 18 堆:字符串字节 "小豆" 的 UTF-8 JS 对象:属性名 → 值的动态映射,可随手加字段 { name: "小豆", age: 18 } u.email = "x" ✓ 运行时随便加 Rust 中 u.email = "x" ❌ 编译错误: 字段必须在 struct 定义里声明过
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 前后:栈上的「遥控器」与堆上的「电视」
String 在栈上存 3 个字:ptr / len / cap;真正的字节在堆上 s1(已作废) ptr | len=2 | cap=2 ✗ 禁止再用 s2(新所有者) ptr | len=2 | cap=2 堆内存(只有一份) 'h' 'i' move 只复制栈上 3 个字, 堆数据一个字节都没动 s2 出作用域时释放一次, 不会双重释放 若允许 s1 继续用:两个变量各 drop 一次同一块堆内存 → 双重释放(C++ 经典崩溃)
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(非词法生命周期):借用的有效期到「最后一次使用」为止,不是到花括号结束——所以「先读完再改」的直觉写法大多能编过。

借用规则:读写不共存
✓ 合法:共享只读 &s(读者1) &s(读者2) &s(读者3) 数据 s 没人能改 → 读得安心 ✗ 非法:读写共存 / 双写 &s(正在读) &mut s(要改) 数据 s 读到一半被改?! E0502 / E0499:编译期直接拒绝
「多读 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 —— 所以参数首选 &str
String 的三件套与 &str 的取景框
owned : String(栈) ptr → 堆 | len = 10 cap = 16(预留座位) 堆:UTF-8 字节,每格 1 字节 你 (3B) 好 , R u s t cap 预留区 一个汉字 = 3 字节 &owned[0..6] 胖指针:ptr + len=6 &str 只是「窗口」:不拥有数据、不能扩容, 但保证框住的是完整字符(否则编译/运行拦截) &owned[0..1] → panic!切在「你」字第 1 字节处,不是字符边界
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,不 panic

8.3 拆盒工具速查

工具行为适用场景
match穷尽所有形态,可绑定数据正式业务逻辑(首选)
if let只匹配一种形态,其余忽略「有就处理、没有拉倒」
unwrap_or(默认值)None 时用兜底值有合理默认值
? 运算符None/Err 提前返回(第 10 章)向调用者传播「没有」
unwrap()None 时直接 panic仅限测试/原型/逻辑上不可能为 None
null 的事故路径 vs Option 的强制拆盒
JS:null 混进正常值里畅通无阻 find() → null user.name(没检查) 运行时 TypeError 💥 Rust:类型不同,不拆盒根本用不了 Option<String> match 拆盒 Some / None 都必须写 两条路都有交代 ✓
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 引用是裸地址,搬家必须靠编译期检查保护。

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 是后厨着火:整家店停止营业(线程终止),因为继续做饭只会更糟。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());
}
? 在每个调用点的分流逻辑
File::open(path)? 产生 Result<File, Error> Ok(file) → 拆包,继续下一行 快乐路径,零额外代码 Err(e) → return Err(e.into()) 当前函数立即结束,错误交给调用者 注意:? 不是 panic, 是「普通的提前 return」 前提:当前函数的返回类型得是 Result(或 Option 等兼容类型),否则「上抛」无处可抛 → 编译错误。
? = 「成功拆包继续走,失败原样往上抛」——把 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」(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)
静态:编译期「开多条生产线」 notify<T: Summary> 一份泛型源码 notify(Article) 机器码 notify(String) 机器码 直接调用、可内联 → 最快;代价:每种类型一份代码,二进制变大 动态:只留一条线,运行时「查表再跳」 &dyn Summary vtable(函数表) summarize → 地址 实际类型的方法(一份) dyn 适合「一个 Vec 装多种类型」: Vec<Box<dyn Summary>>
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 是对外开放窗口:没开窗口的部门,外人一律进不去(默认私有)。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:: 当前模块
可见性:每一层都要开窗口
crate(公司大院) mod front_of_house(私有部门) pub mod hosting(开窗口 ✓) pub fn add_to_waitlist ✓ fn seat_at_table(私有 ✗) 外部 crate 的调用 经 pub use 重导出的短路径 ✓ 走开着的窗 ✗ 私有函数被拒
路径上任何一层没 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 引用计数的一生
owner1 owner2 堆数据 + 计数 = 2 Rc::clone 只加计数,不拷数据 owner1 出作用域 → 计数 2→1,数据还活着 owner2 出作用域 → 计数 1→0 归零瞬间自动 drop,释放堆内存 若 A、B 互持 Rc → 计数永不归零 = 泄漏 破环:一边改用 Weak(不计数、不保活)
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:3
HANDS-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 = 「可以让多人同时隔着玻璃看」。类比边界:检查员只防「两人同时改一口锅」(数据竞争),不防死锁——两人各攥着对方要的钥匙互相等,编译器不管,得靠设计。

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,稳定无竞态
通道:所有权顺着管道流动
线程A · tx.clone() 线程B · tx.clone() 管道队列(先进先出) send(msg) = msg 所有权入队 主线程 · rx recv 独占拿到值 同一份数据任一时刻只属于一个线程 → 根本不存在「两人同时改」;对照 Go 的 channel 思路同源,但 Rust 连「send 之后还偷用原值」都编译报错。
通道把并发问题化简为所有权问题:值在管道里流动,任何时刻只有一个主人。
⚠ 高频陷阱: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 只是拿到订单小票,后厨根本没开火;.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 唤醒
未启动 调用 async fn 只到这 首次 poll Pending(等 IO) 执行器转身去跑别的任务 IO 就绪 → waker 唤醒 → 再 poll Ready(值) .await 表达式拿到结果 编译器把 async fn 改写成状态机:每个 .await 是一个暂停点;「等待」不占线程,一根线程可轮流推进成千上万个 Future。
Future = 惰性状态机 + poll/waker 协议;执行器(tokio)负责「谁就绪就跑谁」,这就是异步高并发的底层。
维度JS PromiseRust 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 错)。
渝ICP备2026024724号-1