[!info] related notes

• 所属总入口：Rust MOC
• 对象介绍：Rust
• 设计哲学：Rust 的工程约束与设计哲学
• 阶段地图：Rust 语言基础 MOC · Rust 所有权与类型系统 MOC · Rust 错误资源与抽象 MOC · Rust 并发与异步 MOC · Rust 工具链与工程结构 MOC · Rust 测试与质量 MOC · Rust 标准库与应用 MOC · Rust 进阶与 unsafe MOC · Rust 系统与服务工程 MOC

Rust 学习路线 MOC

这个概念为什么出现

没有依赖顺序的笔记库会制造假进度：会写 println! 却不懂所有权，会调 async 框架却不会读 Result。本路线把「从零到可交付系统/服务」拆成七个阶段，作为学习与复习的主路径。结构对齐知识库中已验证的 Go 学习路线，但按 Rust 真实模型裁剪：所有权贯穿中前期，错误用 Result 而非异常主路径，阶段六偏生命周期/智能指针/unsafe 而非 GC。

[!abstract] 路线结论 先建立“不可变默认 + 程序骨架”，再建立“所有权如何流动”，随后进入错误、资源与抽象；并发必须连同 Send/Sync 与取消一起学，最后用 Cargo、测试与标准库/生态能力完成真实程序，需要时再下沉到 unsafe 与 FFI。

学 Rust 最怕把“语法会写”和“借用检查器真正建立起来”混为一谈。整条路线围绕五个问题展开：

1. 这门语言默认如何思考数据的拥有与借用
2. 为什么可变性要显式、共享与可变不能同时放飞
3. 为什么错误处理以 Result/Option 为主路径
4. 为什么并发安全是类型系统的一部分
5. 为什么 Cargo 与模块可见性是语言体验的一部分

如何使用这份路线

场景	做法
从零开始	按阶段编号顺序读；每篇先跑最小示例，再看规则与边界
已有 Go/Java/TS 经验	可加速阶段一语法，但不要跳过所有权、生命周期与 Result
只抓主干	看文末「8 个主干主题」和「0 到 1 完成标准」
查某一主题	先定位阶段表中的文件名，再打开对应笔记；细节在原子笔记，不在本页展开

难度标记

• L1 入门 · L2 基础巩固 · L3 核心心智 · L4 工程/并发 · L5 进阶与 unsafe
• 源码：否 / 建议 / 需要 —— 是否值得对照 Reference、标准库或编译器相关资料加深

依赖关系总图

flowchart TD
    S1["阶段一 基本认知"] --> S2["阶段二 所有权与类型"]
    S2 --> S3["阶段三 错误、资源与抽象"]
    S3 --> S4["阶段四 并发与异步"]
    S3 --> S5["阶段五 工程化开发"]
    S4 --> S5
    S5 --> S6["阶段六 进阶与 unsafe"]
    S5 --> S7["阶段七 真实项目能力"]
    S4 --> S7
    S6 --> S7

箭头表示认知依赖，不表示前一阶段必须全部背完。每个阶段都应运行最小例子并观察编译器反馈。

阶段与子 MOC 对照

阶段	目标	主要子 MOC
一	建立 Rust 默认思维方式与程序骨架	Rust 语言基础 MOC · Rust 工具链与工程结构 MOC
二	理解所有权、借用、切片与类型抽象	Rust 所有权与类型系统 MOC
三	Result/Option、Drop、迭代器与组合抽象	错误资源与抽象 · 标准库
四	线程、消息、共享状态、async	并发与异步
五	Cargo、模块、测试、质量工具与项目结构	工具链 · 测试质量 · 系统与服务
六	生命周期进阶、智能指针、unsafe、宏、FFI	进阶与 unsafe
七	CLI、HTTP、序列化与服务交付	标准库 · 系统与服务

---

阶段一：基本认知

目标：能解释 Rust 为何出现；装好工具链；写出 main、理解不可变默认、基本类型、表达式与控制流、函数。

完成标准：

• 能用 rustc/cargo 跑通 hello 与简单测试
• 能说明 let / let mut / 遮蔽的差异
• 能独立写分支与循环，并读懂编译器类型报错
• 知道标量类型、元组、数组与函数签名的基本形状

序号	笔记	核心问题	难度	源码
1.1	Rust 的工程约束与设计哲学	为何需要无 GC 的内存安全与并发安全	L2	否
1.2	安装 Rust 并运行第一个程序	如何建立可验证的 rustup/cargo 闭环	L1	否
1.3	Rust 程序结构	crate、main、语句与表达式如何组织	L2	否
1.4	Rust 的变量、可变性与遮蔽	为何默认不可变，遮蔽与 mut 有何不同	L2	否
1.5	Rust 基本类型	标量与复合类型如何表示数据	L2	否
1.6	Rust 运算符与表达式	表达式语言特征如何影响返回值	L2	否
1.7	Rust 流程控制	if/loop/while/for 与 match 入门	L2	否
1.8	Rust 函数	参数、返回值、语句与表达式返回	L2	否

---

阶段二：所有权与类型模型

目标：建立 Rust 区别于多数语言的核心心智——所有权如何移动、借用如何约束读写、类型如何用 struct/enum/trait 建模。

完成标准：

• 能预测 move 后变量是否仍可用
• 能解释共享引用与可变引用的互斥规则
• 能用切片安全观察集合的一部分
• 能用 struct/enum/trait 描述领域模型，并用 match 穷尽处理

序号	笔记	核心问题	难度	源码
2.1	Rust 所有权	值何时 move、copy、drop	L3	建议
2.2	Rust 借用与引用	共享借用与可变借用如何共存约束	L3	建议
2.3	Rust 切片	切片如何安全引用连续序列	L3	否
2.4	Rust 字符串	String 与 &str、UTF-8 边界	L3	否
2.5	Rust 的 struct 与方法	结构体如何聚合数据并附着方法	L2	否
2.6	Rust 枚举与模式匹配	枚举如何表达“多形态数据”	L3	否
2.7	Rust 集合：Vec 与 HashMap	动态数组与哈希表的所有权接口	L3	否
2.8	Rust Trait	trait 如何定义共享行为	L3	建议
2.9	Rust 泛型	类型参数如何在编译期单态化	L3	建议
2.10	Rust 生命周期	生命周期注解解决什么借用问题	L4	建议

---

阶段三：错误、资源与抽象

目标：把可恢复错误放进类型系统；用 RAII/Drop 管理资源；用迭代器与闭包做组合式数据处理。

完成标准：

• 能在 API 边界正确选择 Result / Option / panic
• 能用 ? 传播错误并保留上下文（thiserror/anyhow 可后置）
• 能解释值离开作用域时如何释放资源
• 能写常见迭代器适配器链并理解惰性

序号	笔记	核心问题	难度	源码
3.1	Rust Option 与 Result	缺席与失败如何进入类型系统	L3	否
3.2	Rust 错误处理	何时 Result、何时 panic、如何组错误类型	L3	否
3.3	Rust Drop 与 RAII	析构与资源释放如何与作用域绑定	L3	建议
3.4	Rust 迭代器	Iterator 如何统一集合处理	L3	建议
3.5	Rust 闭包	闭包如何捕获环境与 Fn 家族差异	L3	否
3.6	Rust 智能指针	Box/Rc/RefCell 解决什么所有权形状	L4	建议
3.7	Rust 标准库 I/O	Read/Write 如何抽象字节流	L3	否

---

阶段四：并发与异步

目标：建立线程、消息传递、共享状态与 async 运行时的完整心智；理解 Send/Sync 如何把数据竞争挡在编译期。

完成标准：

• 能说明为何数据竞争在安全 Rust 中被类型系统拒绝
• 能在 channel 与 Mutex 之间做合理选择
• 能写基础 async fn 并理解 Future 需被执行器驱动
• 知道取消、超时与结构化并发在生态中的常见做法

序号	笔记	核心问题	难度	源码
4.1	Rust 线程	如何启动线程与转移所有权到线程	L3	否
4.2	Rust Send 与 Sync	哪些类型可跨线程移动或共享	L4	建议
4.3	Rust channel	消息传递如何降低共享可变状态	L3	否
4.4	Rust 共享状态并发	Mutex/RwLock/Arc 如何组合	L4	否
4.5	Rust async/await	Future 与 .await 的执行模型	L4	建议
4.6	Tokio 概览	运行时提供什么、何时引入	L4	否
4.7	Rust 并发模式概览	扇入扇出、背压、取消与泄漏防护	L4	否

---

阶段五：工程化开发

目标：用 Cargo 组织包与依赖；用模块控制可见性；用测试与静态检查形成质量闭环；建立可维护项目结构。

完成标准：

• 能读懂 Cargo.toml 并管理依赖与 feature
• 能划分 mod/pub 边界，避免“全 pub”
• 能写单元/集成/文档测试，并跑 Clippy 与 rustfmt
• 能为中小型服务/库画出分层边界

序号	笔记	核心问题	难度	源码
5.1	Cargo	Cargo 如何统一构建与依赖	L2	否
5.2	Rustup	工具链、组件与 target 如何管理	L2	否
5.3	Rust 模块、crate 与可见性	路径与 pub 边界如何设计	L3	否
5.4	Rust Cargo workspace	多 crate 仓库如何组织	L3	否
5.5	Rust 测试	单元/集成/文档测试如何分工	L3	否
5.6	Rust Clippy 与 rustfmt	风格与静态检查如何默认化	L2	否
5.7	Rust 文档测试	文档示例如何保持可运行	L2	否
5.8	Rust 项目结构与分层	bin/lib/内部模块如何分层	L3	否
5.9	Rust 基准测试	如何用 criterion 等测量而非臆测	L4	否

---

阶段六：进阶与 unsafe

目标：在安全抽象之上理解更难的生命周期形状、内部可变性、unsafe 契约、宏与 FFI；明确“规范保证 vs 实现细节”。

完成标准：

• 能读懂常见生命周期标注与 elision 规则
• 知道何时 RefCell/Cell 合理，何时是设计味道
• 能说明 unsafe 不关闭借用检查的全部规则，只扩大信任边界
• 能写最小 FFI 绑定并说明安全封装责任

序号	笔记	核心问题	难度	源码
6.1	Rust 生命周期进阶	结构体字段与多输入生命周期如何标注	L5	建议
6.2	Rust 内部可变性	共享引用下如何安全变更	L4	建议
6.3	Rust unsafe	unsafe 扩大了什么责任	L5	需要
6.4	Rust 宏	declarative/procedural 宏适用边界	L4	建议
6.5	Rust FFI	与 C ABI 协作的安全边界	L5	需要
6.6	Rust 性能方法论	测量、基准与零成本抽象的取舍	L4	否

未定义行为、布局、niche optimization 等细节以 Reference 与当前工具链文档为准，勿把一次实验写成语言永久承诺。

---

阶段七：真实项目能力

目标：用标准库与克制生态交付 CLI、HTTP 服务、序列化与可运维部署。

完成标准：

• 能独立完成 CLI（参数、错误、退出码）
• 能搭一个可测试的 HTTP 服务骨架（路由、状态、优雅关闭思路）
• 能用 Serde 处理 JSON 等格式
• 能把日志、配置、容器化纳入交付清单

序号	笔记	核心问题	难度	源码
7.1	使用标准库构建 CLI	无第三方时如何做可测试 CLI	L3	否
7.2	使用 clap 构建 CLI	声明式参数解析如何落地	L3	否
7.3	构建 Rust HTTP 服务	如何用生态搭可测试服务	L3	否
7.4	Rust Serde 与序列化	派生与手工实现的边界	L3	否
7.5	Rust 文件系统操作	路径、读写与错误处理	L2	否
7.6	Rust 日志与 tracing	结构化日志如何接入	L3	否
7.7	Rust 配置管理	环境变量/文件/分层配置	L3	否
7.8	Rust 优雅关闭	信号、取消与连接排空	L4	否
7.9	Rust 可观测性	metrics/logs/traces 联动	L4	否
7.10	Rust Docker 部署	多阶段构建与体积优化	L3	否

---

如果只抓主干，优先这 8 个主题

1. 变量、可变性与遮蔽
2. 所有权
3. 借用与引用
4. struct 与方法 / 枚举与模式匹配
5. Option 与 Result
6. Trait
7. 错误处理
8. Send 与 Sync / async/await

一条实用学习原则

不要把 Rust 学成“背 trait bound 和框架宏”。先把 所有权、借用、类型建模、错误处理 四条主线学稳，再进入 async、工程化与 unsafe。

0 到 1 的完成标准

• 能解释 move 后为何不能再用，以及 Copy 类型例外
• 能解释为何不能同时存在别名可变引用
• 能用 Result 设计函数边界并用 ? 传播
• 能写 #[test] 并理解 cargo test 组织方式
• 能说明 Send/Sync 与数据竞争的关系
• 能完成一个小 CLI 或小 HTTP 服务闭环
• 能区分“语言安全保证”和“unsafe 块内的额外契约”

认知跳跃提醒（按路线可规避）

1. 未理解所有权就学生命周期注解 → 先 2.1 / 2.2，再 2.10
2. 未理解 Result 就上 async 错误处理 → 先 3.1 / 3.2
3. 未理解 Send/Sync 就共享可变状态 → 先 4.2 / 4.4
4. 未建立安全抽象就写 unsafe → 先阶段二/三，再 6.3

相关入口

• 总地图：Rust MOC
• 对象定位：Rust
• 设计哲学：Rust 的工程约束与设计哲学
• 安装验收：安装 Rust 并运行第一个程序
• 工具：Rustup · Cargo

自测题

1. 为什么所有权阶段要放在并发之前，而不是“语法全会了再学”？
2. 阶段六 unsafe 笔记与阶段二借用笔记应如何配合阅读？
3. 若时间有限，优先抓哪 8 个主干主题？

答案

1. 并发安全依赖类型系统对所有权与共享的约束；跳过所有权会把编译器错误当成噪声。
2. 先掌握安全借用规则，再理解 unsafe 扩大的是“程序员保证”的边界，而不是关闭全部检查。
3. 可变性、所有权、借用、struct/enum、Option/Result、trait、错误处理、Send/Sync 或 async。