Rust程序设计语言 on 编程那些事儿

01-入门指南

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第1章

入门指南

本章目标：安装 Rust → 手写 Hello World → 用 Cargo 管理项目。

安装

推荐用 rustup 安装稳定版 Rust（Linux/macOS：curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh；Windows 见 rust-lang.org/tools/install）。
需要 链接器：macOS 用 xcode-select --install；Linux 装 GCC/Clang；Windows 安装 Visual Studio（MSVC）。
验证：rustc --version；Cargo 随 rustup 一并安装，cargo --version。
常用命令：rustup update（更新）、rustup self uninstall（卸载）、rustup doc（本地文档）。

故障排除（Troubleshooting）

rustc --version 失败时，检查 %PATH% / $env:Path / $PATH 是否包含 Rust 工具链目录。

02-编写一个猜数字游戏

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第2章

编写一个猜数字游戏

规则：程序生成 1–100 随机数，用户猜，提示太大/太小，猜对退出。

准备一个新项目

1
2
3


cargo new guessing_game
cd guessing_game
cargo run

处理一次猜测

使用变量储存值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


use std::io;

fn main() {
 println!("Guess the number!");
 println!("Please input your guess.");

 let mut guess = String::new(); // mut = 可变；String::new() 关联函数

 io::stdin()
 .read_line(&mut guess)
 .expect("Failed to read line");

 println!("You guessed: {guess}");
}

let 默认不可变；let mut 可变。
::new：String 的 关联函数（不接收实例）。
&mut guess：引用，允许多处访问同一数据；可变引用才能被 read_line 追加内容。

使用 `Result` 类型来处理潜在的错误

read_line 返回 Result<T, E> 枚举：Ok(T) 成功，Err(E) 失败。
.expect("msg")：Err 时 panic 并打印消息；生产代码应做 proper 错误处理（第9章）。

使用 `println!` 占位符打印值

1
2
3


let x = 5;
let y = 10;
println!("x = {x} and y + 2 = {}", y + 2); // x = 5 and y + 2 = 12

生成一个秘密数字

使用 crate 来增加更多功能

二进制 crate：可执行项目；库 crate：供他人使用的代码。
在 Cargo.toml 添加依赖：

1
2


[dependencies]
rand = "0.8.5"

0.8.5 即 ^0.8.5（SemVer）：≥0.8.5 且 <0.9.0。
cargo build 从 crates.io 下载并编译依赖。

Cargo.lock 文件确保可重现构建

首次构建写入 Cargo.lock，锁定具体版本；应提交到版本控制。
cargo update 在 SemVer 约束内升级依赖。

生成一个随机数

1
2
3


use rand::Rng;

let secret_number = rand::thread_rng().gen_range(1..=100);

use rand::Rng：trait 必须在作用域内才能调用 gen_range。
1..=100：闭区间 range。
cargo doc --open 查看依赖文档。

比较猜测的数字和秘密数字

1
2
3
4
5
6
7


use std::cmp::Ordering;

match guess.cmp(&secret_number) {
 Ordering::Less => println!("Too small!"),
 Ordering::Greater => println!("Too big!"),
 Ordering::Equal => println!("You win!"),
}

match：模式匹配，第一个匹配的分支执行。
guess 是 String，secret_number 是数字 → 需类型转换。

Shadowing + parse：

03-常见编程概念

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第3章

常见编程概念

变量、基本类型、函数、注释、控制流——几乎每个 Rust 程序都会用到。

变量和可变性

默认不可变：let x = 5; 不能再赋值。
可变：let mut x = 5;
不可变利于推导与安全；需要修改时显式 mut。

常量

1

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

const（非 let），必须标注类型，编译期可求值。
命名：全大写 + 下划线；可在全局作用域。

遮蔽

1
2
3
4
5
6
7


let x = 5;
let x = x + 1; // 新变量，仍不可变
{
 let x = x * 2; // 内部作用域遮蔽
 println!("{x}"); // 12
}
println!("{x}"); // 6

再次 let 同名 = 遮蔽，可 改变类型（mut 不能改类型）。
典型：let spaces = " "; let spaces = spaces.len();

数据类型

静态类型：编译期确定所有变量类型；推断失败时需类型注解。

04-认识所有权

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第4章

认识所有权

所有权（ownership）：Rust 管理内存的核心规则集，编译期检查，无 GC，运行时零开销。

什么是所有权？

栈（Stack）与堆（Heap）

	栈	堆
特点	LIFO，已知固定大小	分配器找空间，返回指针
速度	快	较慢（需通过指针访问）
存放	已知大小数据	编译时未知或可变大小数据

函数调用：参数与局部变量压栈，结束出栈。
所有权主要管理 堆数据 的分配与释放。

所有权规则

每个值有且仅有一个 所有者（owner）。
任一时刻只有一个所有者。
所有者离开作用域，值被 drop（释放内存）。

变量作用域

1
2
3
4


{ // s 尚未有效
 let s = "hello"; // 从此有效
 // 使用 s
} // 作用域结束，s 不再有效

`String` 类型

1
2


let mut s = String::from("hello");
s.push_str(", world!");

字面值 &str：硬编码进二进制，不可变。
String：堆上分配，可增长；String::from("hello") 请求堆内存。

内存与分配

离开作用域时 Rust 自动调用 drop 释放堆内存（类似 C++ RAII）。

使用移动的变量与数据交互

Copy 类型（栈上，如 i32）：

05-使用结构体组织相关联的数据

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第5章

使用结构体组织相关联的数据

结构体（struct）：自定义类型，把多个相关值命名组合在一起（类似 OOP 的数据属性）。

结构体的定义和实例化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


struct User {
 active: bool,
 username: String,
 email: String,
 sign_in_count: u64,
}

let user1 = User {
 email: String::from("someone@example.com"),
 username: String::from("someusername123"),
 active: true,
 sign_in_count: 1,
};

let email = user1.email; // 点号访问
user1.active = false; // 整个实例须 mut；不能单独 mut 字段

字段顺序与实例化顺序无关。
函数末尾构造 struct 可隐式返回。

使用字段初始化简写语法

参数名与字段名相同时：

06-枚举和模式匹配

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第6章

枚举和模式匹配

枚举（enum）：列举类型所有可能变体（variants），把含义与数据编码在一起。

枚举的定义

1
2
3
4
5
6
7


enum IpAddrKind {
 V4,
 V6,
}

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

变体在类型命名空间下：IpAddrKind::V4。

枚举值

变体可 携带数据，各变体类型/数量可不同：

07-包、Crates与模块

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第7章

包、Crates 与模块

大型项目需要组织代码：包（Cargo 构建单元）、crate（编译最小单位）、模块（分组 + 控制私有性）、路径（命名项）、use（引入作用域）。

08-常见集合

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第8章

常见集合

集合数据在堆上，大小运行时可变。本章三种：Vec、String、HashMap。

使用 Vector 储存列表

Vec<T>：同类型、内存相邻、数量可变。

09-错误处理

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第9章

错误处理

Rust 无异常；分两类：

类型	机制	场景
不可恢复	`panic!`	bug、违反契约
可恢复	`Result<T, E>`	文件不存在等可处理失败

用 `panic!` 处理不可恢复的错误

触发方式：显式 panic!；或越界访问等。
默认：展开（unwind）栈并清理；可设 panic = 'abort' 直接终止（release 减小体积）。

1
2


[profile.release]
panic = 'abort'

1

panic!("crash and burn");

使用 `panic!` 的 backtrace

1

RUST_BACKTRACE=1 cargo run

从 backtrace 最上往下找自己项目的第一个帧。

用 `Result` 处理可恢复的错误

1
2
3
4


enum Result<T, E> {
 Ok(T),
 Err(E),
}

1

let f = File::open("hello.txt"); // Result<File, io::Error>

匹配不同的错误

1
2
3
4
5
6
7


let f = File::open("hello.txt").unwrap_or_else(|error| {
 if error.kind() == ErrorKind::NotFound {
 File::create("hello.txt").unwrap_or_else(|e| panic!("create: {e:?}"))
 } else {
 panic!("open: {error:?}")
 }
});

失败时 panic 的快捷方式

unwrap()：Ok 取值，Err 则 panic。
expect("msg")：同上，可自定义 panic 信息（生产更推荐）。

传播错误

函数返回 Result，用 return Err(e) 或 ? 向上传播。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


fn read_username_from_file() -> Result<String, io::Error> {
 let mut s = String::new();
 File::open("hello.txt")?.read_to_string(&mut s)?;
 Ok(s)
}

// 更简
fn read_username_from_file() -> Result<String, io::Error> {
 fs::read_to_string("hello.txt")
}

?：Ok 解包继续；Err 经 From 转换后提前 return。
限制：只能在返回 Result / Option / 实现 FromResidual 的函数中用。
main 可返回 Result<(), Box<dyn Error>>，末尾 Ok(())；Err 退出码非 0。

哪里可以使用 `?` 运算符

Result 上 ? ↔ 返回 Result 的函数；Option 同理；不可混用（需 ok / ok_or 转换）。

要不要 `panic!`

用 `Result`（默认）	用 `panic!`
调用者决定如何处理	不可恢复 / 有害状态
预期可能失败（解析、HTTP 限流）	违反函数契约、无效前置条件
库 API 暴露错误	示例、原型、`unwrap` 占位

示例、代码原型和测试

原型/测试：unwrap / expect 可接受；测试失败即 panic。

当你比编译器知道更多时

逻辑上不可能 Err 时用 expect("原因")，并在消息中说明假设。

错误处理指导原则

有害状态（不变量被破坏）且无法编码进类型 → panic。
用类型系统减少运行时检查（非 Option 即必有值；u32 非负等）。

为验证创建自定义类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


pub struct Guess { value: i32 }

impl Guess {
 pub fn new(value: i32) -> Self {
 if !(1..=100).contains(&value) {
 panic!("Guess must be 1..=100, got {value}");
 }
 Guess { value }
 }
 pub fn value(&self) -> i32 { self.value }
}

私有字段 + new 构造：保证有效范围；API 文档应说明 panic 条件。

10-泛型、Trait和生命周期

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第10章

泛型、Trait 和生命周期

泛型：类型/行为的抽象占位符。Trait：共享行为。生命周期：引用有效性的泛型参数。

提取函数来减少重复

找重复代码 → 2. 提取函数（明确输入输出）→ 3. 调用替换重复处 → 4. 再推广为泛型。

泛型数据类型

在函数定义中使用泛型

1

fn largest<T>(list: &[T]) -> &T { /* ... */ }

类型参数惯例：单字母大驼峰，如 T。
需 trait 约束才能比较：T: PartialOrd（见下节）。

结构体定义中的泛型

1
2


struct Point<T> { x: T, y: T }
struct Point2<T, U> { x: T, y: U }

枚举定义中的泛型

1
2


enum Option<T> { Some(T), None }
enum Result<T, E> { Ok(T), Err(E) }

方法定义中的泛型

1
2
3
4
5
6


impl<T> Point<T> {
 fn x(&self) -> &T { &self.x }
}
impl Point<f32> { // 仅 f32 的专用 impl
 fn distance_from_origin(&self) -> f32 { /* ... */ }
}

impl 后声明的泛型可与结构体泛型不同（如 mixup 方法）。

泛型代码的性能

单态化（monomorphization）：编译期为每个具体类型生成代码 → 零运行时泛型开销。

Trait：定义共同行为

类似其他语言的接口；定义方法签名集合。

定义 trait

1
2
3


pub trait Summary {
 fn summarize(&self) -> String;
}

为类型实现 trait

1
2
3


impl Summary for NewsArticle {
 fn summarize(&self) -> String { /* ... */ }
}

孤儿规则（相干性）：trait 或类型至少一方属于当前 crate，才能 impl。
调用 trait 方法前需 use Summary 引入作用域。

使用默认实现

1
2
3
4
5
6


pub trait Summary {
 fn summarize(&self) -> String {
 String::from("(Read more...)")
 }
}
impl Summary for NewsArticle {} // 用默认

默认实现可调用同 trait 其他方法；不能在 override 里调同名默认实现。

使用 trait 作为参数

1
2
3
4


pub fn notify(item: &impl Summary) { }
pub fn notify<T: Summary>(item: &T) { } // trait 约束语法糖
pub fn notify(item1: &impl Summary, item2: &impl Summary) { } // 可不同类型
pub fn notify<T: Summary>(item1: &T, item2: &T) { } // 必须同类型

通过 `+` 语法指定多个 trait 约束

1
2


fn notify(item: &(impl Summary + Display)) { }
fn notify<T: Summary + Display>(item: &T) { }

通过 `where` 简化 trait 约束

1
2
3
4
5


fn foo<T, U>(t: &T, u: &U) -> i32
where
 T: Display + Clone,
 U: Clone + Debug,
{ }

返回实现了 trait 的类型

1

fn returns_summarizable() -> impl Summary { SocialPost { /* ... */ } }

仅当单一具体返回类型；多类型返回需 trait object（第18章）。

使用 trait 约束有条件地实现方法

1
2
3


impl<T: PartialOrd + Display> Pair<T> {
 fn cmp_display(&self) { /* ... */ }
}

Blanket implementation：impl<T: Display> ToString for T { } — 见 trait 文档 Implementers。

生命周期确保引用有效

每个引用有生命周期（有效作用域）；注解描述多个引用间关系，不改变实际寿命。

悬垂引用

引用不能比被引用数据活得更久；借用检查器比较作用域。

函数中的泛型生命周期

1
2
3


fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
 if x.len() > y.len() { x } else { y }
}

返回引用生命周期 = 两个参数中较短者。
若总返回某一参数，可只标注该参数；不能返回函数内新建值的引用（悬垂）。

生命周期注解语法

1
2
3


&i32
&'a i32
&'a mut i32

写在 & 之后，与类型空格分隔；参数名以 ' 开头，常用 'a。

在函数签名中

生命周期参数写在 <> 中与泛型并列：fn foo<'a>(x: &'a str) -> &'a str

在结构体定义中

1
2
3


struct ImportantExcerpt<'a> {
 part: &'a str,
}

实例不能比 part 引用活得更久。

生命周期省略（Lifetime Elision）

编译器三条规则（fn/impl）：

11-编写自动化测试

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第11章

编写自动化测试

类型系统捕获很多错误；测试验证行为是否符合意图。Rust 支持单元测试与集成测试。

如何编写测试

测试三步：设置 → 执行 → 断言。

精心组织测试函数

1
2
3
4
5
6
7
8
9


#[cfg(test)]
mod tests {
 use super::*;

 #[test]
 fn it_works() {
 assert_eq!(2 + 2, 4);
 }
}

#[test]：标记测试函数；cargo test 运行。
测试在独立线程；panic → 该测试失败。
cargo new adder --lib 自动生成测试模板。

1
2
3


cargo test
# running 1 test ... ok
# test result: ok. 1 passed; 0 failed

使用 `assert!` 宏来检查结果

1
2
3
4


#[test]
fn larger_can_hold_smaller() {
 assert!(larger.can_hold(&smaller));
}

使用 `assert_eq!` 和 `assert_ne!` 宏测试相等

1
2


assert_eq!(add_two(2), 4);
assert_ne!(result, 0);

失败时打印 left / right；需 PartialEq + Debug（可 #[derive(PartialEq, Debug)]）。

自定义失败信息

1

assert!(result.contains("Carol"), "Greeting was: {}", result);

使用 `should_panic` 检查 panic

1
2
3
4
5


#[test]
#[should_panic(expected = "less than or equal to 100")]
fn greater_than_100() {
 Guess::new(200);
}

panic 则通过；无 panic 则失败。expected 匹配 panic 信息子串。

在测试中使用 `Result<T, E>`

1
2
3
4


#[test]
fn it_works() -> Result<(), String> {
 if 2 + 2 == 4 { Ok(()) } else { Err(String::from("two plus two")) }
}

不能用 #[should_panic]；断言 Err 用 assert!(value.is_err())，勿对 Result 用 ?。

控制测试如何运行

1
2
3


cargo test -- [传给测试二进制体的参数]
cargo test --help
cargo test -- --help

并行或顺序运行测试

1

cargo test -- --test-threads=1

默认并行；共享状态/文件时用单线程。

显示函数输出

1

cargo test -- --show-output

默认通过时截获 println!；失败时显示输出。

通过名称运行部分测试

1
2


cargo test one_hundred # 过滤名称（含模块名）
cargo test add # 匹配子串

除非特别指定否则忽略测试

1
2
3


#[test]
#[ignore]
fn expensive_test() { }

1
2


cargo test -- --ignored # 只跑 ignored
cargo test -- --include-ignored # 全部

测试的组织结构

	单元测试	集成测试
位置	`src/*.rs` 内 `#[cfg(test)] mod tests`	项目根 `tests/*.rs`
可见性	可测私有（`use super::*`）	仅 public API
编译	与源码同 crate	每文件独立 crate

单元测试

1
2
3
4
5
6
7
8


#[cfg(test)]
mod tests {
 use super::*;
 #[test]
 fn internal() {
 assert_eq!(internal_adder(2, 2), 4);
 }
}

#[cfg(test)]：cargo build 不包含；cargo test 才编译。

集成测试

1
2
3


adder/
├── src/lib.rs
└── tests/integration_test.rs

1
2
3
4
5
6
7


// tests/integration_test.rs
use adder::add_two;

#[test]
fn it_adds_two() {
 assert_eq!(add_two(2), 4);
}

1

cargo test --test integration_test # 只跑该文件

集成测试中的子模块

共享代码：tests/common/mod.rs + mod common;（不要 tests/common.rs，会被当独立测试 crate）。

12-一个IO项目：构建命令行程序

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第12章

一个 I/O 项目：构建命令行程序

综合第 7–11 章：实现简化版 grep（minigrep）— 在文件中搜索字符串并打印匹配行。

13-函数式语言特性：迭代器与闭包

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第13章

函数式语言特性：迭代器与闭包

本章核心：闭包（存变量、捕获环境）+ 迭代器（惰性序列处理）。

闭包

捕获环境

闭包 = 匿名函数，可捕获定义处作用域的值。
典型：Option::unwrap_or_else(|| self.most_stocked()) — 闭包捕获 self 不可变引用，标准库无需了解你的类型。

推断和注解闭包类型

闭包通常不需显式参数/返回类型注解（编译器推断）。
首次调用后类型锁定；混用不同类型会编译错误。
语法对比：

1
2
3
4


fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;

单表达式可省略 {}；调用后才推断类型（类似 Vec::new() 需后续赋值推断）。

捕获引用或移动所有权

捕获方式	触发条件	示例
不可变借用	只读	`\|list\| println!("{:?}", list)`
可变借用	修改	`\|list\| list.push(7)`
移动所有权	`move` 关键字	传给新线程时强制 move

move 闭包：即使只需不可变引用，也强制取得所有权（线程安全需要）。

将捕获的值移出闭包

三个 Fn trait（决定闭包可被如何使用）：

14-进一步认识Cargo和Crates.io

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第14章

进一步认识 Cargo 和 Crates.io

本章：发布配置 → 发布 crate → 工作空间 → 安装二进制 → 扩展 Cargo。

采用发布配置自定义构建

发布配置（release profiles）：预定义的可定制编译选项集。
两个主要配置：
- dev — cargo build（开发，编译快）
- release — cargo build --release（发布，运行快）

1
2
3
4
5


[profile.dev]
opt-level = 0

[profile.release]
opt-level = 3

opt-level 0–3：越高优化越多，编译越慢。覆盖默认值只需在 Cargo.toml 添加 [profile.*] 段。

将 crate 发布到 Crates.io

编写有用的文档注释

/// — 为后面的项写文档（函数、结构体等）。
//! — 为包含它的项写文档（crate 根、模块）。
cargo doc / cargo doc --open 生成 HTML 文档。
常用章节：# Examples、# Panics、# Errors、# Safety。
文档中的示例代码会被 cargo test 作为文档测试运行。

导出实用的公有 API

pub use 重导出：内部结构不变，对外呈现扁平 API。

1
2
3


pub use self::kinds::PrimaryColor;
pub use self::utils::mix;
// 用户可 use art::PrimaryColor 而非 art::kinds::PrimaryColor

创建 Crates.io 账号

1
2


cargo login
# 粘贴 API token（秘密，存 ~/.cargo/credentials）

向新 crate 添加元数据

1
2
3
4
5


[package]
name = "guessing_game" # crates.io 先到先得
version = "0.1.0"
description = "A fun game..."
license = "MIT OR Apache-2.0" # SPDX 标识符

必填：description、license（或 license-file）。

发布到 Crates.io

1

cargo publish

发布永久性：版本不可覆盖/删除。遵循语义化版本。

发布现有 crate 的新版本

修改 version，再 cargo publish。

使用 `cargo yank` 从 Crates.io 撤回版本

1
2


cargo yank --vers 1.0.1
cargo yank --vers 1.0.1 --undo

yank 阻止新项目依赖该版本；已有 Cargo.lock 的项目不受影响。不删除代码。

Cargo 工作空间

工作空间：共享一个 Cargo.lock 和 target/ 的多个包。

1
2
3
4


# 顶层 Cargo.toml
[workspace]
resolver = "3"
members = ["adder", "add_one"]

在工作空间内 cargo new 自动加入 members。
成员间依赖需显式声明路径依赖；Cargo 不自动假设成员互相依赖。
顶层唯一 Cargo.lock — 所有 crate 使用相同依赖版本。
某 crate 用了 rand，其他 crate 不能直接用，须各自声明依赖。
运行/测试/发布指定成员：cargo run -p adder、cargo test -p add_one。

使用 `cargo install` 安装二进制文件

1
2


cargo install ripgrep
# 安装到 ~/.cargo/bin/（需加入 PATH）

仅安装含二进制目标（src/main.rs）的 crate，非库 crate。

使用自定义命令扩展 Cargo

$PATH 中有 cargo-something 二进制 → 可用 cargo something 运行。
cargo --list 显示所有可用子命令（含自定义）。
可用 cargo install 安装扩展命令。

总结

Cargo + crates.io 是 Rust 生态核心：分享代码、组织大项目、安装工具。

15-智能指针

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第15章

智能指针

指针 = 含内存地址的变量。智能指针 = 类似指针 + 额外元数据/功能；通常拥有所指向的数据。

标准库常用：Box<T>、Rc<T>、RefCell<T>。智能指针实现 Deref 和 Drop trait。

16-无畏并发

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第16章

无畏并发

Rust 用所有权 + 类型系统在编译时捕获并发错误 → 无畏并发（fearless concurrency）。

并发 = 独立执行；并行 = 同时执行。本章聚焦并发。

17-异步编程基础：Async、Await、Future与Stream

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第17章

异步编程基础：Async、Await、Future 与 Stream

异步 = 操作可能暂停、稍后恢复；运行时管理执行。CPU 密集型 → 线程；I/O 密集型 → async。

并发：单核切换任务（交替推进）。
并行：多核同时执行。

Future 与 async 语法

Future：将来某时刻就绪的值（实现 Future trait）。
async fn / async { } → 编译为返回 future 的函数/块。
await 是后缀关键字：future.await（Rust 特有）。
Future 惰性：不 await 就不执行（编译器警告未使用 future）。

1
2
3
4
5
6
7
8


async fn page_title(url: &str) -> Option<String> {
 let text = trpl::get(url).await.text().await;
 Html::parse(&text).select_first("title").map(|t| t.inner_html())
}
// 等价于：
fn page_title(url: &str) -> impl Future<Output = Option<String>> {
 async move { /* ... */ }
}

使用运行时执行异步函数

main 不能是 async fn — 需要运行时初始化。
Rust 无内置运行时，需选第三方（如 tokio）。

1
2
3
4
5
6


fn main() {
 trpl::block_on(async {
 let title = page_title(url).await;
 // ...
 });
}

每个 await 点 = 可能暂停并交还控制权给运行时。
编译器自动生成状态机管理暂停/恢复。

让两个 URL 并发竞争

1
2
3
4


let (url, page_title) = match trpl::select(title_fut_1, title_fut_2).await {
 trpl::Either::Left(left) => left,
 trpl::Either::Right(right) => right,
};

使用 async 实现并发

使用 `spawn_task` 创建新任务

1
2


trpl::spawn_task(async { /* ... */ });
// 类似 thread::spawn，但由运行时管理，非 OS 线程

任务句柄是 future → handle.await.unwrap() 等待完成。
trpl::join(fut1, fut2).await — 两个 future 都完成（公平交替）。

通过消息传递在两个任务之间发送数据

1
2
3


let (tx, rx) = trpl::channel();
// tx.send(msg) — 不阻塞
// rx.recv().await — 异步等待

关键：单个 async 块内代码线性执行，无并发。
要并发 → 分成多个 async 块 + trpl::join / join!。
async move — 将所有权移入块，块结束时 drop（关闭信道发送端）。

1
2
3


let tx_fut = async move { /* send */ };
let rx_fut = async { /* recv */ };
trpl::join(tx_fut, rx_fut).await;

while let Some(msg) = rx.recv().await { ... } — 接收直到信道关闭。
join! 宏 — 等待编译期已知数量的 future。

将控制权交还给运行时

await 点之间全是同步执行 → 长计算会饿死其他 future。
主动交出：trpl::yield_now().await（比 sleep 更轻量）。
协作式多任务：每个 future 负责在适当时交出控制权。

构建我们自己的异步抽象

1
2
3
4
5
6


async fn timeout<F: Future>(future_to_try: F, max_time: Duration) -> Result<F::Output, Duration> {
 match trpl::select(future_to_try, trpl::sleep(max_time)).await {
 trpl::Either::Left(output) => Ok(output),
 trpl::Either::Right(_) => Err(max_time),
 }
}

Stream：按顺序出现的 Future

Stream = 异步版迭代器（条目随时间到达）。
需 use trpl::StreamExt 才能用 .next().await。

1
2
3
4


let stream = trpl::stream_from_iter(iter);
while let Some(value) = stream.next().await {
 println!("{value}");
}

Stream trait 提供 poll_next；StreamExt 提供 next 等高层 API。

深入理解 async 相关的 trait

`Future` trait

1
2
3
4
5
6


pub trait Future {
 type Output;
 fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

pub enum Poll<T> { Ready(T), Pending }

poll → Ready(值) 或 Pending（稍后重试）。
await 底层 = 循环 poll + 运行时调度。

`Pin` 类型与 `Unpin` trait

async 状态机可能自引用 → 移动不安全。
Pin 保证被 pin 的值不移动。
Unpin — 标记 trait，表示可以安全移动（大多数类型）。
!Unpin — 特殊标记，不能移动（async 生成的 future）。
动态 future 集合：pin!(fut) 或 Box::pin(fut)。

`Stream` trait

1
2
3
4


trait Stream {
 type Item;
 fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
}

合并 Iterator::next + Future::poll 语义。

结合起来看：Future、任务与线程

层级	类比	管理
线程	OS 级并发边界	操作系统
任务	async 并发边界	运行时
Future	最细粒度并发单位	运行时 executor

选择指南：

18-面向对象编程特性

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第18章

面向对象编程特性

Rust 受 OOP 影响，但无继承。本章：OOP 三特征在 Rust 中的体现 + trait 对象 + 状态模式。

面向对象语言的特征

对象包含数据和行为

GoF 定义：对象 = 数据 + 操作数据的方法。
Rust：struct/enum 存数据 + impl 块提供方法 → 功能等价（只是不叫"对象"）。

封装隐藏了实现细节

1
2
3
4
5
6
7
8


pub struct AveragedCollection {
 list: Vec<i32>, // 私有
 average: f64, // 私有
}
impl AveragedCollection {
 pub fn add(&mut self, v: i32) { /* 更新 list + average */ }
 pub fn average(&self) -> f64 { self.average }
}

pub 控制可见性；私有字段 + 公有方法 = 封装。
可改内部实现（如 Vec → HashSet）而不影响外部 API。

作为类型系统与代码共享的继承

Rust 无继承（不能用宏以外的方式继承字段/方法）。
代码复用 → trait 默认实现（类似但不等同继承）。
运行时多态 → trait 对象（非继承）。

使用 trait object 来抽象出共享行为

定义通用行为的 trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


pub trait Draw { fn draw(&self); }

pub struct Screen {
 components: Vec<Box<dyn Draw>>,
}

impl Screen {
 pub fn run(&self) {
 for component in self.components.iter() {
 component.draw(); // 动态分发
 }
 }
}

dyn Trait = trait 对象：运行时查找方法。
需用指针（&、Box 等）+ dyn 关键字。

实现 trait

1
2
3


pub struct Button { width: u32, height: u32, label: String }
impl Draw for Button { fn draw(&self) { /* ... */ } }
// 用户 crate 可扩展：impl Draw for SelectBox { ... }

trait 对象执行动态分发

	泛型 + trait 约束	trait 对象
类型	编译时单态化	运行时多类型
分发	静态分发	动态分发
集合	同质（全 Button 或全 TextField）	异质（Button + SelectBox 混合）
性能	可内联优化	运行时查找开销
扩展	编译时已知类型	运行时添加新类型

未实现 trait 的类型不能放入 trait 对象 → 编译时检查（优于鸭子类型的运行时错误）。
trait 对象不能添加数据，只抽象行为。

实现一个面向对象设计模式

尝试采用传统的面向对象风格

状态模式：值内含状态对象，行为随状态改变。

19-模式与模式匹配

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第19章

模式与模式匹配

模式（pattern）描述数据形状，与值匹配后可用其中的命名部分。组成：字面值、解构、变量、通配符、占位符。

所有可以使用模式的位置

`match` 分支

1
2
3


match VALUE {
 PATTERN => EXPRESSION,
}

必须穷尽（exhaustive）；最后一支常用 _ 捕获剩余情况。
_ 匹配任意值但不绑定变量。

`let` 语句

1

let PATTERN = EXPRESSION;

let x = 5; 中 x 就是模式；可解构元组：let (x, y, z) = (1, 2, 3);
元素数量须与模式一致，否则编译错误；可用 _ / .. 忽略多余项。

条件 `if let` 表达式

简写只匹配一种情况的 match；可有 else / else if / else if let。
模式可引入新变量并遮蔽外部同名变量。
不检查穷尽性——漏分支编译器不报错。

`while let` 条件循环

模式持续匹配时循环；如 while let Ok(value) = rx.recv() 处理信道消息。

`for` 循环

for x in y 中 x 是模式；enumerate 配合 (index, value) 解构常见。

函数参数

参数列表即模式；可解构元组：fn print_coords(&(x, y): &(i32, i32))。
闭包参数同理。

可反驳性：模式是否可能匹配失败

类型	含义	示例
不可反驳	对任意值都能匹配	`let x = 5;` 中的 `x`
可反驳	某些值匹配失败	`Some(x)` 对 `None` 失败

只能不可反驳：let、for、函数参数。

20-高级特性

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第20章

高级特性

偶尔遇到、不必天天用；可作陌生语法时的查阅参考。

不安全 Rust

unsafe Rust 不强制部分内存安全保证，提供五种超能力（须在 unsafe { } 块或标记函数/trait 内使用）：

21-最后的项目：构建多线程web server

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文第21章

最后的项目：构建多线程 web server

综合复习项目：手写基础 HTTP server + 线程池。非生产最佳实践（可用 crates.io 现成库），目的是理解底层机制；本章不用 async/await。

构建单线程 web server

监听 TCP 连接

1
2
3
4
5


let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
 let stream = stream.unwrap();
 handle_connection(stream);
}

std::net::TcpListener：bind 绑定端口（7878 ≈ “rust”）；incoming() 迭代连接尝试。
浏览器可能多连接（favicon、预连接等）；无响应时连接 drop 关闭，浏览器或重连。

读取请求

1
2
3
4
5
6
7
8


fn handle_connection(mut stream: TcpStream) {
 let buf_reader = BufReader::new(&stream);
 let http_request: Vec<_> = buf_reader
 .lines()
 .map(|l| l.unwrap())
 .take_while(|l| !l.is_empty())
 .collect();
}

BufReader + lines() 按行读；连续两个 \r\n（空行）标志请求头结束。
请求行格式：Method Request-URI HTTP-Version CRLF

更仔细地观察 HTTP 请求

1
2
3
4


GET / HTTP/1.1
Host: 127.0.0.1:7878
...
（空行）

第一行：方法（GET/POST）、URI（如 /）、HTTP 版本。
后续为 header；GET 通常无 body。

编写响应

1

HTTP/1.1 200 OK\r\n\r\n

状态行 + headers + 空行 + body。
stream.write_all(response.as_bytes())

返回真正的 HTML

读 hello.html；响应加 Content-Length header。
format! 拼状态行、header、body。

验证请求并有选择的进行响应

只匹配 GET / HTTP/1.1 → 200 + hello.html。
其他 → 404 + 404.html。
重构：let (status_line, filename) = if ... else ...; + let 解构，消除重复读写逻辑。

将单线程 server 变为多线程 server

模拟慢请求

/sleep 分支 thread::sleep(Duration::from_secs(5))。
单线程下慢请求阻塞后续请求 → 需并发。

使用线程池改善吞吐量

线程池：固定数量 worker 线程 + 任务队列；限制并发防 DoS。

22-附录

Tue, 28 Jul 2026 14:49:00 +0800

精要笔记 · 基于 TRPL 简体中文附录

附录

Rust 学习旅途中的参考资料速查。

附录 A：关键字

目前正在使用的关键字

关键字	用途
`as`	类型转换、消除歧义、`use` 重命名
`async` / `await`	异步 Future
`break` / `continue`	循环控制
`const`	常量、常量裸指针
`crate`	模块路径中的 crate 根
`dyn`	trait 对象动态分发
`else`	`if` / `if let` 分支
`enum` / `struct` / `trait`	类型定义
`extern`	外部函数/变量链接
`fn`	函数或函数指针类型
`for`	迭代、`impl Trait`、高阶生命周期
`if` / `match` / `while` / `loop`	控制流
`impl`	实现方法或 trait
`let` / `mut` / `ref`	绑定、可变性、引用绑定
`move`	闭包获取捕获项所有权
`pub`	公有可见性
`return`	函数返回
`Self` / `self`	类型别名 / 方法接收者 / 当前模块
`static`	全局变量、`'static` 生命周期
`super`	父模块
`type`	类型别名、关联类型
`union`	联合体（仅声明处）
`unsafe`	不安全代码/trait/impl
`use`	引入作用域
`where`	泛型约束
`true` / `false`	布尔字面量
`in`	`for` 循环语法

为将来使用保留的关键字

abstract、become、box、do、final、gen、macro、override、priv、try、typeof、unsized、virtual、yield

Rust程序设计语言 on 编程那些事儿

01-入门指南

入门指南

安装

故障排除（Troubleshooting）

02-编写一个猜数字游戏

编写一个猜数字游戏

准备一个新项目

处理一次猜测

使用变量储存值

使用 Result 类型来处理潜在的错误

使用 println! 占位符打印值

生成一个秘密数字

使用 crate 来增加更多功能

Cargo.lock 文件确保可重现构建

生成一个随机数

比较猜测的数字和秘密数字

03-常见编程概念

常见编程概念

变量和可变性

常量

遮蔽

数据类型

04-认识所有权

认识所有权

什么是所有权？

栈（Stack）与堆（Heap）

所有权规则

变量作用域

String 类型

内存与分配

使用移动的变量与数据交互

05-使用结构体组织相关联的数据

使用结构体组织相关联的数据

结构体的定义和实例化

使用字段初始化简写语法

06-枚举和模式匹配

枚举和模式匹配

枚举的定义

枚举值

07-包、Crates与模块

包、Crates 与模块

08-常见集合

常见集合

使用 Vector 储存列表

09-错误处理

错误处理

用 panic! 处理不可恢复的错误

使用 panic! 的 backtrace

用 Result 处理可恢复的错误

匹配不同的错误

失败时 panic 的快捷方式

传播错误

哪里可以使用 ? 运算符

要不要 panic!

示例、代码原型和测试

当你比编译器知道更多时

错误处理指导原则

为验证创建自定义类型

10-泛型、Trait和生命周期

泛型、Trait 和生命周期

提取函数来减少重复

泛型数据类型

在函数定义中使用泛型

结构体定义中的泛型

枚举定义中的泛型

方法定义中的泛型

泛型代码的性能

Trait：定义共同行为

定义 trait

为类型实现 trait

使用默认实现

使用 trait 作为参数

通过 + 语法指定多个 trait 约束

通过 where 简化 trait 约束

返回实现了 trait 的类型

使用 trait 约束有条件地实现方法

生命周期确保引用有效

悬垂引用

函数中的泛型生命周期

使用 `Result` 类型来处理潜在的错误

使用 `println!` 占位符打印值

`String` 类型

用 `panic!` 处理不可恢复的错误

使用 `panic!` 的 backtrace

用 `Result` 处理可恢复的错误

哪里可以使用 `?` 运算符

要不要 `panic!`

通过 `+` 语法指定多个 trait 约束

通过 `where` 简化 trait 约束

使用 `assert!` 宏来检查结果

使用 `assert_eq!` 和 `assert_ne!` 宏测试相等

使用 `should_panic` 检查 panic

在测试中使用 `Result<T, E>`

使用 `cargo yank` 从 Crates.io 撤回版本

使用 `cargo install` 安装二进制文件

使用 `spawn_task` 创建新任务

`Future` trait

`Pin` 类型与 `Unpin` trait

`Stream` trait