1 介绍
1.1 主要特征
01.简介
a.来历
Rust语言由Mozilla研究院的Graydon Hoare于2006年开始设计
最初是Graydon的个人项目，旨在创建一个安全、并发、实用的系统编程语言
2009年Mozilla开始赞助这个项目，2010年项目首次公开
2015年5月15日发布1.0稳定版本，标志着Rust正式进入生产环境
b.设计理念
Rust的核心理念是在保证内存安全的同时不牺牲性能
通过所有权系统在编译期保证内存安全，无需垃圾回收器
零成本抽象：高级特性不会带来运行时开销
并发无畏：类型系统保证线程安全，避免数据竞争
c.优点
内存安全：通过所有权系统在编译期防止空指针、悬垂指针等内存错误
线程安全：类型系统保证并发代码的安全性，编译期检测数据竞争
零成本抽象：高级特性编译后性能接近手写的底层代码
现代工具链：Cargo包管理器提供依赖管理、构建、测试一体化解决方案
丰富的类型系统：支持泛型、特征、模式匹配等现代语言特性
优秀的错误处理：Result和Option类型强制显式处理错误
d.Rust语言的主要特征
所有权系统：每个值都有唯一的所有者，通过借用规则管理内存
生命周期：编译器跟踪引用的有效期，防止悬垂引用
模式匹配：强大的match表达式支持复杂的条件分支
特征系统：类似接口但更强大，支持默认实现和关联类型
宏系统：编译期代码生成，支持声明式和过程式宏
并发原语：提供线程、消息传递、共享状态等多种并发模型
类型推导：编译器自动推导大部分类型，减少冗余代码
错误处理：Result和Option强制处理错误，panic用于不可恢复错误
02.Rust命名规范
a.命名规则
变量和函数：使用snake_case（小写字母+下划线）
类型和特征：使用PascalCase（大写字母开头的驼峰）
常量和静态变量：使用SCREAMING_SNAKE_CASE（全大写+下划线）
生命周期参数：使用小写字母，通常是'a、'b等单字母
b.关键字
Rust有严格的关键字列表，分为强关键字和弱关键字
强关键字：as break const continue crate else enum extern
false fn for if impl in let loop match mod move mut
pub ref return self Self static struct super trait
true type unsafe use where while
弱关键字：abstract async await become box do final macro
override priv try typeof unsized virtual yield
c.可见性
私有：默认情况下，所有项都是私有的
公开：使用pub关键字标记为公开
模块内公开：pub(crate)在当前crate内公开
父模块公开：pub(super)对父模块公开
路径公开：pub(in path)对指定路径公开
03.main函数和模块系统
a.main函数
Rust程序的入口点是main函数
标准形式：fn main() { }
可返回Result：fn main() -> Result<(), Box<dyn Error>> { }
支持异步：#[tokio::main] async fn main() { }
b.模块系统
使用mod关键字定义模块
使用use关键字导入模块或项
模块可以嵌套定义，形成层次结构
文件系统映射：mod foo会查找foo.rs或foo/mod.rs
c.包和Crate
包（Package）：包含一个Cargo.toml和一个或多个crate
Crate：编译单元，可以是二进制crate或库crate
二进制crate：包含main函数，可执行
库crate：提供功能给其他crate使用
04.输入输出
a.标准输出
print!宏：打印不换行
println!宏：打印并换行
eprint!宏：打印到标准错误不换行
eprintln!宏：打印到标准错误并换行
format!宏：格式化字符串但不输出
b.标准输入
使用std::io::stdin()获取标准输入
read_line方法读取一行输入
需要处理Result类型的返回值
示例：let mut input = String::new(); std::io::stdin().read_line(&mut input)?;
c.格式化
{}：Display特征格式化
{:?}：Debug特征格式化
{:#?}：Debug特征美化格式化
{:b}：二进制格式
{:o}：八进制格式
{:x}：十六进制格式（小写）
{:X}：十六进制格式（大写）
{:p}：指针格式
05.内置类型和常用特征
a.标量类型
整数：i8 i16 i32 i64 i128 isize（有符号）
u8 u16 u32 u64 u128 usize（无符号）
浮点数：f32 f64
布尔：bool（true/false）
字符：char（Unicode标量值，4字节）
b.复合类型
元组：(T1, T2, ...) 固定长度，可包含不同类型
数组：[T; N] 固定长度，元素类型相同
切片：&[T] 动态大小，数组或Vec的视图
c.常用特征
Copy：按位复制的类型
Clone：可克隆的类型
Debug：可调试打印
Display：可格式化显示
PartialEq/Eq：可比较相等性
PartialOrd/Ord：可比较大小
Default：有默认值
06.Cargo工具
a.基本命令
cargo new：创建新项目
cargo build：构建项目
cargo run：构建并运行项目
cargo test：运行测试
cargo doc：生成文档
cargo check：检查代码但不生成可执行文件
b.依赖管理
在Cargo.toml的[dependencies]部分添加依赖
支持版本号、Git仓库、本地路径等多种来源
cargo update更新依赖到兼容的最新版本
Cargo.lock锁定依赖版本，保证可重现构建
c.工作空间
多个相关包可以组织在一个工作空间中
共享Cargo.lock和target目录
在根目录Cargo.toml中使用[workspace]配置
1.2 核心概念
01.所有权（Ownership）
a.基本规则
每个值都有一个所有者变量
同一时间只能有一个所有者
当所有者离开作用域时，值被丢弃
这些规则在编译期强制执行，无运行时开销
b.移动语义
将值赋给另一个变量时，所有权发生转移
原变量不再有效，不能继续使用
这避免了双重释放等内存安全问题
示例：let s1 = String::from("hello"); let s2 = s1; // s1不再有效
c.克隆
使用clone方法进行深拷贝
克隆会复制堆上的数据，开销较大
实现Copy特征的类型会自动复制而非移动
栈上的简单类型（整数、布尔等）默认实现Copy
02.借用（Borrowing）
a.不可变借用
使用&创建不可变引用
可以同时存在多个不可变引用
不可变引用期间不能修改数据
示例：let r1 = &s; let r2 = &s; // 允许多个不可变引用
b.可变借用
使用&mut创建可变引用
同一时间只能有一个可变引用
可变引用期间不能有其他引用（可变或不可变）
这在编译期防止数据竞争
c.借用规则
引用必须始终有效（不能悬垂）
要么有一个可变引用，要么有任意数量的不可变引用
引用的作用域从创建开始到最后一次使用
编译器通过借用检查器强制执行这些规则
03.生命周期（Lifetime）
a.概念
生命周期是引用保持有效的作用域
编译器使用生命周期防止悬垂引用
大多数情况下生命周期是隐式的，编译器自动推导
某些情况需要显式标注生命周期参数
b.生命周期标注
使用'a、'b等标记生命周期参数
函数签名中标注：fn foo<'a>(x: &'a str) -> &'a str
结构体中标注：struct Foo<'a> { x: &'a str }
生命周期标注不改变引用的实际生命周期，只是描述关系
c.生命周期省略规则
函数参数的生命周期称为输入生命周期
返回值的生命周期称为输出生命周期
规则1：每个引用参数都有独立的生命周期
规则2：只有一个输入生命周期时，赋给所有输出生命周期
规则3：多个输入生命周期，其中一个是&self或&mut self，self的生命周期赋给所有输出
04.类型系统
a.静态类型
Rust是静态类型语言，编译期确定所有类型
类型推导减少了显式类型标注的需要
泛型提供编译期多态，零运行时开销
特征对象提供运行时多态，有虚表开销
b.类型安全
强类型系统防止类型错误
不允许隐式类型转换
使用as进行显式类型转换
From/Into特征提供类型转换
c.零大小类型
某些类型在运行时不占用空间
单元类型()、空元组、PhantomData等
用于类型级编程和标记
05.模式匹配
a.match表达式
必须穷尽所有可能的情况
每个分支返回相同类型的值
支持守卫条件：match x { n if n > 0 => ... }
可以解构复杂的数据结构
b.if let
简化只关心一个模式的match
语法：if let Some(x) = option_value { }
可以配合else使用
适合处理Option和Result
c.while let
循环直到模式不再匹配
语法：while let Some(x) = stack.pop() { }
常用于迭代器和栈操作
06.错误处理
a.Result类型
表示可能失败的操作：Result<T, E>
Ok(T)表示成功，Err(E)表示失败
必须处理Result，否则编译器警告
使用?操作符简化错误传播
b.Option类型
表示可能不存在的值：Option<T>
Some(T)表示有值，None表示无值
避免空指针错误
提供丰富的组合子方法：map、and_then等
c.panic
用于不可恢复的错误
panic!宏触发panic
展开栈并清理资源，或直接终止
可以通过std::panic::catch_unwind捕获
07.智能指针
a.Box<T>
在堆上分配值
实现了Deref和Drop特征
用于递归类型、大型数据、特征对象
所有权明确，离开作用域自动释放
b.Rc<T>
引用计数智能指针
允许多个所有者共享数据
只能用于单线程
clone增加引用计数，drop减少计数
c.Arc<T>
原子引用计数，线程安全版本的Rc
可以在多线程间共享数据
配合Mutex或RwLock使用
性能略低于Rc但保证线程安全
08.迭代器
a.Iterator特征
定义了next方法返回Option<Item>
提供丰富的适配器方法：map、filter、fold等
惰性求值，只在消费时才执行
零成本抽象，性能接近手写循环
b.常用方法
map：转换每个元素
filter：过滤元素
fold：累积计算
collect：收集到集合
chain：连接迭代器
zip：组合两个迭代器
c.自定义迭代器
实现Iterator特征
定义Item关联类型
实现next方法
可选实现size_hint等优化方法
1.3 优缺点
01.优点
a.内存安全
所有权系统在编译期保证内存安全
无需垃圾回收器即可防止内存泄漏
编译期检测空指针、悬垂指针、缓冲区溢出
避免use-after-free等常见内存错误
b.线程安全
类型系统保证并发代码的安全性
Send和Sync特征标记线程安全类型
编译期检测数据竞争
无畏并发：编译器帮助避免并发错误
c.零成本抽象
高级特性编译后性能接近C/C++
泛型通过单态化实现零运行时开销
迭代器优化后性能等同手写循环
智能指针的开销在编译期消除
d.现代语言特性
强大的类型系统支持泛型和特征
模式匹配简化复杂的条件逻辑
宏系统支持元编程
函数式编程特性：闭包、迭代器、组合子
e.优秀的工具链
Cargo统一管理依赖、构建、测试、文档
rustfmt自动格式化代码
clippy提供lint检查和最佳实践建议
rust-analyzer提供强大的IDE支持
f.错误处理
Result和Option强制显式处理错误
?操作符简化错误传播
类型系统保证错误不会被忽略
编译期检查所有错误路径
02.缺点
a.学习曲线陡峭
所有权和借用概念需要时间理解
生命周期标注对初学者有挑战
编译器错误信息虽详细但初期难懂
需要改变传统的编程思维方式
b.编译时间较长
编译器进行大量静态分析和优化
大型项目编译时间可能较长
增量编译有所改善但仍不如动态语言
泛型的单态化增加编译时间
c.生态系统相对年轻
某些领域的库不如成熟语言丰富
部分库的API可能不够稳定
文档和教程相对较少
社区规模小于Java、Python等
d.异步编程复杂
异步运行时需要额外依赖
多个异步运行时选择可能困惑
异步代码的生命周期更复杂
错误消息在异步上下文中更难理解
e.互操作性
与C/C++互操作需要unsafe代码
FFI绑定需要手动编写或生成
某些平台支持不如C/C++完善
嵌入式开发生态仍在发展
f.开发速度
严格的编译器检查可能降低初期开发速度
需要更多时间满足借用检查器
重构代码可能需要大量修改
原型开发不如动态语言快速
1.4 使用场景
01.系统编程
a.操作系统开发
Rust适合编写操作系统内核
Redox OS是完全用Rust编写的操作系统
内存安全保证减少内核漏洞
无需运行时和垃圾回收器
b.设备驱动
编写安全的设备驱动程序
避免传统C驱动的内存错误
类型系统保证硬件访问安全
适合嵌入式系统开发
c.文件系统
实现高性能文件系统
保证并发访问的安全性
零成本抽象不影响性能
TiKV等数据库使用Rust
02.网络服务
a.Web后端
Actix-web、Rocket等高性能Web框架
异步运行时支持高并发
类型安全的API设计
内存效率高，适合微服务
b.网络代理
编写高性能代理服务器
Linkerd2-proxy使用Rust
安全处理网络流量
低延迟高吞吐量
c.API服务
构建RESTful和gRPC服务
类型安全的序列化/反序列化
优秀的错误处理机制
适合云原生应用
03.命令行工具
a.系统工具
ripgrep、fd、bat等现代化工具
性能优于传统Unix工具
跨平台支持
单一可执行文件，易于分发
b.开发工具
编译器、构建工具、代码分析器
Rust编译器本身用Rust编写
swc、deno等JavaScript工具
性能关键的开发工具
c.数据处理
日志分析、数据转换工具
并发处理大量数据
内存安全避免崩溃
高性能I/O操作
04.嵌入式开发
a.微控制器
支持ARM Cortex-M等嵌入式平台
no_std环境下运行
内存占用小
类型安全的硬件抽象层
b.物联网设备
适合资源受限的设备
无需垃圾回收器
确定性的内存管理
安全的固件更新
c.实时系统
可预测的性能特性
无GC暂停
精确的内存控制
适合硬实时需求
05.区块链和加密货币
a.区块链节点
Polkadot、Solana等使用Rust
安全处理加密操作
高性能网络通信
并发处理交易
b.智能合约
Near、Solana支持Rust智能合约
类型安全减少合约漏洞
高效的执行性能
形式化验证友好
c.加密库
实现安全的加密算法
防止时序攻击
内存安全避免密钥泄露
RustCrypto项目
06.游戏开发
a.游戏引擎
Bevy等ECS游戏引擎
高性能图形渲染
并发的游戏逻辑
跨平台支持
b.游戏工具
资源管理工具
关卡编辑器
性能分析工具
构建流水线
c.游戏服务器
高并发的多人游戏服务器
低延迟网络通信
安全的游戏逻辑
防作弊机制
07.WebAssembly
a.浏览器应用
编译到WASM在浏览器运行
性能接近原生代码
Yew等前端框架
与JavaScript互操作
b.服务端WASM
Wasmtime、Wasmer运行时
安全的插件系统
边缘计算应用
Serverless函数
c.跨平台应用
一次编写，多平台运行
桌面、移动、Web统一代码
Tauri等应用框架
原生性能体验
08.数据库和存储
a.数据库引擎
TiKV分布式KV存储
Databend云原生数据仓库
高性能查询引擎
安全的并发控制
b.缓存系统
内存缓存实现
分布式缓存节点
高吞吐低延迟
数据一致性保证
c.对象存储
S3兼容存储系统
文件系统实现
数据压缩和加密
高可用性设计
1.5 所有权系统
01.所有权基础
a.所有权规则
Rust中每个值都有一个所有者
任何时候值只能有一个所有者
当所有者离开作用域，值将被丢弃
这些规则在编译时强制执行
b.变量作用域
变量从声明开始有效
一直持续到当前作用域结束
作用域结束时自动调用drop函数
示例：{ let s = String::from("hello"); } // s在此处被drop
c.内存分配
栈上分配：固定大小的类型（整数、布尔等）
堆上分配：动态大小的类型（String、Vec等）
Box<T>显式在堆上分配
所有权系统管理堆内存的释放
02.移动语义
a.值的移动
将值赋给另一个变量时发生移动
原变量失效，不能再使用
避免双重释放问题
示例：let s1 = String::from("hello"); let s2 = s1; // s1失效
b.函数参数
将值传递给函数会发生移动
函数获得值的所有权
原变量在函数调用后失效
示例：fn take(s: String) { } let s = String::from("hello"); take(s); // s失效
c.函数返回值
函数可以返回值的所有权
返回值的所有权转移给调用者
可以通过返回值转移所有权
示例：fn give() -> String { String::from("hello") } let s = give();
d.移动与Copy
实现Copy特征的类型会复制而非移动
Copy类型包括：整数、浮点数、布尔、字符、元组（元素都是Copy）
String、Vec等不实现Copy
自定义类型可以派生Copy（如果所有字段都是Copy）
03.引用和借用
a.不可变引用
使用&创建引用而不获取所有权
可以同时存在多个不可变引用
引用期间不能修改数据
示例：let s = String::from("hello"); let r1 = &s; let r2 = &s;
b.可变引用
使用&mut创建可变引用
同一时间只能有一个可变引用
可变引用期间不能有其他引用
示例：let mut s = String::from("hello"); let r = &mut s;
c.借用规则
在任意给定时间，要么只能有一个可变引用，要么只能有多个不可变引用
引用必须总是有效的
编译器通过借用检查器强制执行
违反规则会导致编译错误
d.悬垂引用
Rust编译器防止悬垂引用
引用的生命周期不能超过被引用的值
编译器检查引用的有效性
示例（编译错误）：fn dangle() -> &String { &String::from("hello") }
04.切片类型
a.字符串切片
&str是字符串切片类型
引用String的一部分
语法：&s[start..end]
字符串字面量就是切片：let s = "hello";
b.数组切片
&[T]是数组切片类型
引用数组或Vec的一部分
语法：&arr[start..end]
示例：let arr = [1, 2, 3, 4, 5]; let slice = &arr[1..3];
c.切片的不可变性
切片是引用，遵循借用规则
不可变切片：&[T]或&str
可变切片：&mut [T]
切片不拥有数据，只是视图
05.所有权模式
a.RAII模式
资源获取即初始化
构造函数获取资源
析构函数释放资源
Rust通过Drop特征实现
b.移动构造
Rust默认使用移动语义
避免不必要的拷贝
提高性能
需要拷贝时显式clone
c.借用而非拥有
优先使用引用而非所有权转移
减少不必要的内存分配
保持原变量可用
函数参数常用引用
d.返回所有权
函数可以返回所有权
允许链式调用
构建器模式常用
示例：builder.set_name("foo").set_age(30).build()
06.智能指针与所有权
a.Box<T>
堆分配的所有权指针
单一所有者
离开作用域自动释放
用于递归类型和大对象
b.Rc<T>
引用计数指针
多个所有者共享数据
只读访问
单线程使用
c.Arc<T>
原子引用计数
多线程共享所有权
配合Mutex使用
线程安全
d.RefCell<T>
内部可变性
运行时借用检查
单线程使用
违反规则会panic
07.所有权与性能
a.零成本抽象
所有权检查在编译期完成
运行时无额外开销
性能等同手动内存管理
安全性由编译器保证
b.避免拷贝
移动语义避免不必要的拷贝
引用避免所有权转移
Copy类型的拷贝成本低
大对象使用Box或引用
c.内存布局
所有权不影响内存布局
编译器优化移除中间变量
内联优化消除函数调用
LLVM后端进一步优化
d.缓存友好
连续内存布局
Vec比链表性能好
迭代器零成本抽象
避免间接访问
1.6 生命周期机制
01.生命周期基础
a.生命周期概念
生命周期是引用保持有效的作用域
编译器使用生命周期防止悬垂引用
生命周期是编译期概念，无运行时开销
大多数情况下生命周期是隐式的
b.生命周期标注语法
使用单引号加小写字母：'a、'b、'c
标注在引用类型的&符号后：&'a str
多个引用可以有相同或不同的生命周期
生命周期参数在泛型参数列表中声明
c.为什么需要生命周期
防止悬垂引用
确保引用在使用时始终有效
编译器需要知道引用之间的关系
某些情况编译器无法自动推导
02.函数中的生命周期
a.函数签名中的生命周期
语法：fn foo<'a>(x: &'a str) -> &'a str
表示返回值的生命周期与参数相同
多个参数可以有不同的生命周期
示例：fn longest<'a>(x: &'a str, y: &'a str) -> &'a str
b.生命周期约束
返回引用的生命周期必须来自参数
不能返回函数内部创建的引用
编译器检查生命周期关系
示例（错误）：fn foo<'a>() -> &'a str { &String::from("hello") }
c.多个生命周期参数
不同参数可以有不同的生命周期
语法：fn foo<'a, 'b>(x: &'a str, y: &'b str) -> &'a str
返回值的生命周期可以是其中之一
编译器根据返回值推断约束
03.结构体中的生命周期
a.结构体定义
包含引用的结构体需要生命周期标注
语法：struct Foo<'a> { x: &'a str }
确保结构体不会比其引用的数据活得更久
示例：struct ImportantExcerpt<'a> { part: &'a str }
b.结构体方法
impl块也需要声明生命周期
语法：impl<'a> Foo<'a> { fn bar(&self) -> &'a str }
方法可以引入新的生命周期参数
self的生命周期通常省略
c.多个生命周期
结构体可以有多个生命周期参数
不同字段可以有不同的生命周期
语法：struct Foo<'a, 'b> { x: &'a str, y: &'b str }
增加复杂性，应尽量避免
04.生命周期省略规则
a.输入生命周期
函数参数的生命周期称为输入生命周期
每个引用参数都有自己的生命周期
规则1：每个引用参数都有独立的生命周期
示例：fn foo(x: &str, y: &str) 等价于 fn foo<'a, 'b>(x: &'a str, y: &'b str)
b.输出生命周期
返回值的生命周期称为输出生命周期
规则2：如果只有一个输入生命周期，赋给所有输出
示例：fn foo(x: &str) -> &str 等价于 fn foo<'a>(x: &'a str) -> &'a str
简化常见情况的标注
c.方法的特殊规则
规则3：如果有多个输入生命周期，其中一个是&self或&mut self
self的生命周期赋给所有输出生命周期
示例：fn foo(&self, x: &str) -> &str 返回值生命周期与self相同
这是最常见的方法模式
d.何时需要显式标注
不满足省略规则时需要显式标注
多个输入生命周期且返回引用
编译器无法推导时会报错
根据错误提示添加标注
05.生命周期约束
a.生命周期子类型
'a: 'b 表示'a至少和'b一样长
用于约束生命周期之间的关系
示例：struct Foo<'a, 'b: 'a> { x: &'a str, y: &'b str }
确保引用的有效性
b.特征约束中的生命周期
特征可以有生命周期参数
实现特征时需要指定生命周期
语法：impl<'a> Trait<'a> for Foo<'a>
生命周期约束可以组合
c.where子句
复杂的生命周期约束使用where
语法：fn foo<'a, 'b>(x: &'a str, y: &'b str) where 'a: 'b
提高可读性
支持复杂的约束关系
06.静态生命周期
a.'static生命周期
'static表示整个程序运行期间
字符串字面量有'static生命周期
示例：let s: &'static str = "hello";
全局变量和常量是'static
b.使用场景
字符串字面量
全局常量
泄漏的内存（Box::leak）
线程间共享的静态数据
c.注意事项
不要滥用'static
大多数情况不需要'static
考虑使用所有权而非'static引用
'static约束很严格
07.高级生命周期特性
a.生命周期协变
生命周期的子类型关系
&'a T 对于'a是协变的
&'a mut T 对于'a是协变的
编译器自动处理
b.高阶生命周期
for<'a>语法表示任意生命周期
用于函数指针和闭包
示例：fn foo(f: for<'a> fn(&'a str) -> &'a str)
高级特性，少用
c.生命周期与闭包
闭包自动推导生命周期
捕获的引用影响闭包的生命周期
Fn特征有生命周期约束
通常不需要显式标注
d.PhantomData
标记未使用的生命周期参数
用于类型级编程
语法：struct Foo<'a> { _marker: PhantomData<&'a ()> }
零大小类型，无运行时开销
08.生命周期最佳实践
a.优先使用省略规则
让编译器自动推导
只在必要时显式标注
保持代码简洁
遵循惯用模式
b.避免过度复杂
减少生命周期参数数量
考虑使用所有权而非引用
重构复杂的生命周期关系
使用新类型模式简化
c.理解编译器错误
仔细阅读错误信息
编译器会建议生命周期标注
理解引用的有效范围
使用rustc --explain查看详细说明
d.常见模式
返回self的引用：使用self的生命周期
迭代器：使用集合的生命周期
构建器模式：链式调用保持生命周期
缓存：考虑使用Rc或Arc
1.7 类型系统
01.类型系统基础
a.静态强类型
Rust是静态类型语言，编译期确定所有类型
强类型系统，不允许隐式类型转换
类型安全防止类型错误
编译期类型检查，无运行时类型错误
b.类型推导
编译器自动推导大部分类型
let x = 5; // 推导为i32
let v = vec![1, 2, 3]; // 推导为Vec<i32>
减少冗余的类型标注
c.类型标注
必要时显式标注类型
let x: i32 = 5;
let v: Vec<i32> = Vec::new();
提高代码可读性
d.类型别名
使用type关键字创建类型别名
type Result<T> = std::result::Result<T, std::io::Error>;
简化复杂类型
提高代码可维护性
02.泛型
a.泛型函数
函数可以使用类型参数
fn foo<T>(x: T) -> T { x }
支持多个类型参数
示例：fn bar<T, U>(x: T, y: U) -> (T, U) { (x, y) }
b.泛型结构体
结构体可以使用类型参数
struct Point<T> { x: T, y: T }
不同类型参数创建不同的具体类型
示例：Point<i32>和Point<f64>是不同类型
c.泛型枚举
枚举可以使用类型参数
Option<T>和Result<T, E>是泛型枚举
每个变体可以使用类型参数
示例：enum Option<T> { Some(T), None }
d.泛型方法
impl块可以使用类型参数
impl<T> Point<T> { fn x(&self) -> &T { &self.x } }
可以为特定类型实现方法
示例：impl Point<f32> { fn distance(&self) -> f32 }
e.单态化
编译器为每个具体类型生成代码
泛型代码编译后无运行时开销
代码膨胀可能增加二进制大小
性能等同手写具体类型代码
03.特征约束
a.特征约束语法
限制泛型参数必须实现某些特征
fn foo<T: Display>(x: T)
多个约束使用+连接
示例：fn bar<T: Display + Clone>(x: T)
b.where子句
复杂约束使用where子句
fn foo<T, U>(x: T, y: U) where T: Display, U: Clone
提高可读性
支持更复杂的约束
c.特征对象
dyn Trait表示特征对象
运行时多态，有虚表开销
示例：Box<dyn Display>
用于异构集合
d.impl Trait
返回实现某特征的类型
fn foo() -> impl Iterator<Item = i32>
隐藏具体类型
简化返回类型
04.关联类型
a.关联类型定义
特征可以有关联类型
trait Iterator { type Item; }
实现时指定具体类型
示例：impl Iterator for Counter { type Item = u32; }
b.与泛型的区别
关联类型每个实现只能有一个
泛型可以有多个实现
关联类型简化特征约束
提高代码可读性
c.使用场景
迭代器的Item类型
运算符重载的Output类型
转换特征的Target类型
避免类型参数过多
05.类型转换
a.as转换
基本类型之间的显式转换
let x = 5i32 as f64;
可能丢失精度或溢出
不安全的转换需要小心
b.From和Into
From<T>定义从T转换
Into<T>自动实现
示例：impl From<i32> for MyType
类型安全的转换
c.TryFrom和TryInto
可能失败的转换
返回Result类型
示例：impl TryFrom<i64> for i32
处理转换错误
d.Deref和AsRef
Deref用于智能指针
AsRef用于引用转换
自动解引用
简化API设计
06.新类型模式
a.新类型定义
struct Meters(f64);
包装现有类型
提供类型安全
零运行时开销
b.使用场景
区分语义相同但用途不同的类型
实现外部类型的特征
隐藏内部实现
提供更好的API
c.透明包装
#[repr(transparent)]
保证内存布局相同
用于FFI
零成本抽象
d.Deref实现
实现Deref自动解引用
访问内部类型的方法
示例：impl Deref for Meters { type Target = f64; }
提供便利的API
07.幻影类型
a.PhantomData
标记未使用的类型参数
struct Foo<T> { _marker: PhantomData<T> }
用于类型级编程
零大小类型
b.使用场景
标记生命周期
类型状态模式
编译期检查
零成本抽象
c.类型状态模式
使用类型表示状态
编译期检查状态转换
示例：struct Connection<State> { _state: PhantomData<State> }
防止无效状态
08.高级类型特性
a.永不类型
!表示永不返回
用于panic、loop等
示例：fn foo() -> ! { panic!() }
类型系统的底类型
b.动态大小类型
DST在编译期大小未知
str、[T]、dyn Trait
必须通过引用或智能指针使用
Sized特征标记固定大小类型
c.零大小类型
()、空结构体、PhantomData
不占用内存空间
用于标记和类型级编程
编译器优化
d.函数指针
fn(i32) -> i32是函数指针类型
可以存储和传递函数
与闭包不同，无捕获
零成本抽象
09.类型系统最佳实践
a.优先使用具体类型
避免过度泛型化
只在需要时使用泛型
保持代码简单
提高可读性
b.使用新类型模式
提供类型安全
隐藏实现细节
防止误用
零成本抽象
c.合理使用特征对象
需要运行时多态时使用
注意性能开销
考虑使用枚举替代
权衡灵活性和性能
d.利用类型系统
编译期检查
类型驱动开发
使用类型表达约束
让编译器帮助你
2 基础语法
2.1 变量与常量
01.变量声明
a.不可变变量
使用let关键字声明
默认不可变，编译期检查
示例：let x = 5;
重新赋值会编译错误
b.可变变量
使用let mut声明
允许修改值
示例：let mut x = 5; x = 6;
必须显式标记mut
c.变量遮蔽
可以重新声明同名变量
新变量遮蔽旧变量
示例：let x = 5; let x = x + 1;
可以改变类型
d.类型推导
编译器自动推导类型
let x = 5; // 推导为i32
必要时需要显式标注
示例：let x: i32 = 5;
02.常量声明
a.const关键字
使用const声明常量
必须标注类型
示例：const MAX_POINTS: u32 = 100_000;
命名约定：全大写加下划线
b.常量特性
编译期求值
不可变，无mut
可以在任何作用域声明
生命周期是整个程序
c.与不可变变量的区别
常量必须是常量表达式
不可变变量可以是运行时值
常量可以在全局作用域
常量内联到使用处
d.使用场景
配置值
魔法数字替代
全局共享常量
编译期计算的值
03.作用域与生命周期
a.块作用域
使用{}创建作用域
变量在作用域结束时销毁
示例：{ let x = 5; } // x在此销毁
内层可以访问外层变量
b.变量遮蔽与作用域
内层作用域可以遮蔽外层变量
离开作用域后恢复外层变量
示例：let x = 5; { let x = 10; } // x恢复为5
不同于可变变量
c.所有权转移
变量赋值可能转移所有权
基本类型实现Copy，不转移
复杂类型默认转移
示例：let s1 = String::from("hello"); let s2 = s1; // s1失效
d.引用作用域
引用的作用域从声明到最后使用
不能超过被引用值的作用域
编译器检查引用有效性
避免悬垂引用
2.2 数据类型
01.标量类型
a.整数类型
有符号：i8, i16, i32, i64, i128, isize
无符号：u8, u16, u32, u64, u128, usize
默认i32
字面量：98_222（下划线分隔）、0xff（十六进制）、0o77（八进制）、0b1111_0000（二进制）
b.浮点类型
f32：32位浮点数
f64：64位浮点数（默认）
示例：let x = 2.0; // f64
IEEE-754标准
c.布尔类型
bool类型
值：true或false
占用1字节
示例：let t = true;
d.字符类型
char类型
Unicode标量值
占用4字节
示例：let c = 'z'; let emoji = '😻';
02.复合类型
a.元组类型
固定长度的异构集合
示例：let tup: (i32, f64, u8) = (500, 6.4, 1);
解构：let (x, y, z) = tup;
索引访问：tup.0, tup.1, tup.2
b.数组类型
固定长度的同构集合
示例：let a: [i32; 5] = [1, 2, 3, 4, 5];
初始化：let a = [3; 5]; // [3, 3, 3, 3, 3]
索引访问：a[0], a
c.切片类型
动态大小的数组视图
示例：let slice = &a[1..3];
不拥有数据，只是引用
类型：&[T]
d.字符串切片
&str类型
字符串字面量是&str
示例：let s = "hello";
UTF-8编码
03.字符串类型
a.String类型
可增长的UTF-8字符串
堆分配
示例：let mut s = String::from("hello");
可变且可增长
b.字符串字面量
&str类型
存储在二进制文件中
不可变
示例：let s = "hello";
c.字符串操作
创建：String::from("hello")、"hello".to_string()
追加：s.push_str("world")、s.push('!')
拼接：format!("{}{}", s1, s2)
切片：&s[0..5]
d.字符串与&str转换
String转&str：&s或s.as_str()
&str转String：s.to_string()或String::from(s)
自动解引用
借用关系
04.类型转换
a.as转换
基本类型之间转换
示例：let x = 5u8 as i32;
可能丢失精度
不安全的转换
b.From和Into
类型安全的转换
示例：let s = String::from("hello");
Into自动实现
用于API设计
c.TryFrom和TryInto
可能失败的转换
返回Result
示例：let x: Result<i32, _> = i32::try_from(128i64);
处理转换错误
d.解引用转换
Deref trait
自动解引用
示例：String -> &str
简化API使用
2.3 运算符
01.算术运算符
a.基本运算
加法：+
减法：-
乘法：*
除法：/（整数除法截断）
取模：%
b.溢出处理
Debug模式：溢出panic
Release模式：环绕
显式方法：wrapping_add、checked_add、saturating_add、overflowing_add
示例：let x = 255u8.wrapping_add(1); // 0
c.类型要求
操作数类型必须相同
不支持隐式转换
需要显式转换
示例：let x = 5i32 + 10i32;
d.复合赋值
+=、-=、*=、/=、%=
示例：x += 1;
等价于x = x + 1
要求变量可变
02.比较运算符
a.相等比较
==：相等
!=：不相等
要求类型相同
返回bool
b.大小比较
>：大于
<：小于
>=：大于等于
<=：小于等于
c.比较要求
类型必须实现PartialEq
基本类型都实现
自定义类型需要派生
示例：#[derive(PartialEq)]
d.特殊值比较
NaN不等于任何值（包括自己）
使用is_nan()检查
浮点数比较需谨慎
考虑精度问题
03.逻辑运算符
a.布尔运算
&&：逻辑与
||：逻辑或
!：逻辑非
短路求值
b.短路特性
&&：左边为false则不计算右边
||：左边为true则不计算右边
利用短路优化性能
示例：if x != 0 && y / x > 5
c.位运算
&：按位与
|：按位或
^：按位异或
!：按位非
d.移位运算
<<：左移
>>：右移
算术右移（有符号）
逻辑右移（无符号）
04.其他运算符
a.引用运算符
&：借用
&mut：可变借用
*：解引用
示例：let r = &x; let v = *r;
b.范围运算符
..：不包含结束
..=：包含结束
示例：1..5（1,2,3,4）、1..=5（1,2,3,4,5）
用于循环和切片
c.类型转换
as：类型转换
示例：let x = 5i32 as f64;
可能不安全
需要小心使用
d.函数调用
()：函数调用
示例：foo(1, 2)
方法调用：obj.method()
关联函数：Type::function()
2.4 控制流
01.条件表达式
a.if表达式
基本语法：if condition { } else { }
条件必须是bool类型
不需要括号
示例：if x > 5 { println!("big"); }
b.else if
多条件判断
示例：if x > 5 { } else if x > 0 { } else { }
按顺序检查
第一个为真的分支执行
c.if作为表达式
可以返回值
示例：let x = if condition { 5 } else { 6 };
所有分支类型必须相同
用于赋值和返回
d.let-if模式
结合模式匹配
示例：if let Some(x) = option { }
简化Option和Result处理
后续章节详述
02.循环
a.loop循环
无限循环
示例：loop { }
使用break退出
可以返回值：break value;
b.while循环
条件循环
示例：while condition { }
条件为false时退出
可以使用break和continue
c.for循环
迭代循环
示例：for item in collection { }
最常用的循环
自动调用into_iter()
d.循环标签
标记循环
示例：'outer: loop { loop { break 'outer; } }
用于嵌套循环
break和continue可以指定标签
03.循环控制
a.break语句
退出循环
可以返回值
示例：let result = loop { break 5; };
可以指定标签
b.continue语句
跳过本次迭代
继续下次迭代
示例：for i in 0..10 { if i % 2 == 0 { continue; } }
可以指定标签
c.循环返回值
loop可以返回值
使用break返回
示例：let x = loop { break 5; };
类型推导
d.迭代器方法
优先使用迭代器
map、filter、fold等
示例：(0..10).filter(|x| x % 2 == 0)
更符合Rust风格
04.模式匹配
a.match表达式
强大的模式匹配
示例：match value { pattern => expression, }
必须穷尽所有可能
编译期检查
b.匹配字面量
直接匹配值
示例：match x { 1 => "one", 2 => "two", _ => "other" }
_匹配任意值
用于默认分支
c.匹配范围
使用..=
示例：match x { 1..=5 => "low", 6..=10 => "high", _ => "other" }
包含边界
用于数值范围
d.匹配守卫
添加额外条件
示例：match x { n if n > 0 => "positive", _ => "other" }
使用if关键字
更灵活的匹配
05.解构匹配
a.元组解构
匹配元组元素
示例：match (x, y) { (0, 0) => "origin", (0, _) => "x-axis", _ => "other" }
_忽略值
可以嵌套
b.结构体解构
匹配结构体字段
示例：match point { Point { x: 0, y } => y, Point { x, y } => x + y }
简写：Point { x, y }
可以重命名
c.枚举解构
匹配枚举变体
示例：match option { Some(x) => x, None => 0 }
提取内部值
必须穷尽
d.引用解构
匹配引用
示例：match &value { &Some(ref x) => x, &None => &0 }
ref关键字
避免所有权转移
06.控制流最佳实践
a.优先使用迭代器
更简洁
更高效
更安全
示例：collection.iter().filter().map()
b.避免过深嵌套
使用early return
提取函数
使用?运算符
保持代码扁平
c.使用match而非if-else链
更清晰
编译器检查穷尽性
更符合Rust风格
示例：match value { ... }
d.利用类型系统
使用Option和Result
避免空值和异常
编译期检查
更安全的代码
2.5 函数
01.函数定义
a.基本语法
使用fn关键字
示例：fn function_name(param: Type) -> ReturnType { }
参数必须标注类型
返回类型可选
b.命名约定
使用snake_case
示例：fn calculate_sum() { }
动词开头
清晰描述功能
c.参数
必须指定类型
示例：fn add(x: i32, y: i32) { }
可以有多个参数
逗号分隔
d.返回值
使用->指定类型
最后表达式作为返回值
示例：fn add(x: i32, y: i32) -> i32 { x + y }
使用return显式返回
02.函数调用
a.普通调用
函数名加括号
示例：let result = add(5, 3);
传递参数
接收返回值
b.方法调用
使用点语法
示例：obj.method()
第一个参数是self
自动借用或解引用
c.关联函数
类型相关的函数
示例：String::from("hello")
使用::调用
不需要实例
d.函数指针
fn类型
示例：let f: fn(i32) -> i32 = add;
可以存储和传递
零成本抽象
03.语句与表达式
a.语句
执行操作，不返回值
示例：let x = 5;
以分号结尾
不能赋值给变量
b.表达式
求值并返回结果
示例：5 + 6
不以分号结尾
可以赋值给变量
c.块表达式
{}创建新作用域
示例：let y = { let x = 3; x + 1 };
最后表达式作为返回值
可以嵌套
d.分号的作用
将表达式转为语句
示例：x + 1; // 语句，返回()
省略分号返回值
示例：x + 1 // 表达式，返回结果
04.返回值
a.隐式返回
最后表达式作为返回值
示例：fn add(x: i32, y: i32) -> i32 { x + y }
不需要return关键字
更简洁
b.显式返回
使用return关键字
示例：return x + y;
提前返回
用于条件返回
c.单元类型
()表示无返回值
示例：fn print() -> () { }
可以省略-> ()
等价于void
d.发散函数
永不返回
类型为!
示例：fn forever() -> ! { loop { } }
用于panic、exit等
05.函数参数模式
a.值传递
默认移动语义
示例：fn take(s: String) { }
所有权转移
调用后原变量失效
b.引用传递
借用参数
示例：fn borrow(s: &String) { }
不转移所有权
可以多次调用
c.可变引用
可变借用
示例：fn modify(s: &mut String) { }
可以修改参数
独占访问
d.模式解构
参数可以是模式
示例：fn print_coordinates(&(x, y): &(i32, i32)) { }
直接解构
简化代码
2.6 注释与文档
01.注释类型
a.行注释
使用//
示例：// 这是行注释
注释到行尾
最常用
b.块注释
使用/* */
示例：/* 这是块注释 */
可以跨行
可以嵌套
c.文档注释
使用///
示例：/// 这是文档注释
生成文档
支持Markdown
d.模块文档
使用//!
示例：//! 这是模块文档
放在文件开头
描述模块功能
02.文档注释
a.基本语法
///开头
支持Markdown格式
示例：/// Returns the sum of two numbers
紧邻被文档化的项
b.文档结构
# Examples：示例代码
# Panics：panic情况
# Errors：错误情况
# Safety：不安全代码说明
c.代码示例
使用```标记
示例：/// ```rust /// let x = add(2, 3); /// ```
自动测试
确保示例正确
d.链接
使用[`item`]链接
示例：/// See [`String`] for details
自动生成链接
方便导航
03.文档生成
a.cargo doc命令
生成HTML文档
示例：cargo doc --open
自动打开浏览器
包含依赖文档
b.文档测试
cargo test运行
测试文档中的示例
确保示例正确
示例代码必须编译
c.文档覆盖
#[doc(hidden)]隐藏项
#[doc(inline)]内联文档
控制文档生成
优化文档结构
d.文档最佳实践
为公共API写文档
提供使用示例
说明panic和错误
保持文档更新
04.注释规范
a.代码注释
解释为什么，不是做什么
代码应该自解释
复杂逻辑需要注释
避免过时注释
b.TODO注释
标记待办事项
示例：// TODO: implement error handling
使用统一格式
定期清理
c.FIXME注释
标记需要修复的问题
示例：// FIXME: this is a temporary workaround
优先级高于TODO
及时处理
d.注释风格
保持简洁
使用完整句子
正确的标点
统一的格式
05.属性
a.外部属性
#[attribute]
示例：#[derive(Debug)]
应用于下一项
控制编译行为
b.内部属性
#![attribute]
示例：#![allow(dead_code)]
应用于包含项
通常在模块顶部
c.常用属性
#[derive]：自动派生trait
#[cfg]：条件编译
#[test]：测试函数
#[allow]、#[warn]、#[deny]：lint控制
d.自定义属性
过程宏
#[my_attribute]
高级特性
用于框架开发
3 容器与集合
3.1 汇总：5个
01.Vec<T>
动态数组，最常用的集合类型
02.VecDeque<T>
双端队列，支持两端高效插入删除
03.HashMap<K, V>
哈希表，键值对存储
04.HashSet<T>
哈希集合，唯一值集合
05.BTreeMap<K, V>和BTreeSet<T>
有序的映射和集合
3.2 Vec动态数组
01.Vec基础
a.创建Vec
Vec::new()：创建空Vec
vec!宏：vec![1, 2, 3]
Vec::with_capacity(n)：预分配容量
示例：let v: Vec<i32> = Vec::new();
b.添加元素
push：尾部添加
示例：v.push(5);
自动扩容
O(1)摊销时间
c.访问元素
索引：v[0]（可能panic）
get：v.get(0)（返回Option）
示例：let third = &v;
借用检查
d.删除元素
pop：移除并返回最后元素
remove：移除指定索引
示例：v.pop();
返回Option<T>
02.Vec操作
a.迭代
iter：不可变迭代
iter_mut：可变迭代
into_iter：消耗Vec
示例：for i in &v { println!("{}", i); }
b.容量管理
len：元素数量
capacity：已分配容量
reserve：预留额外容量
shrink_to_fit：释放多余容量
c.切片操作
&v[start..end]：切片引用
示例：let slice = &v[1..3];
不拥有数据
借用检查
d.转换
to_vec：从切片创建Vec
as_slice：Vec转切片
示例：let v = slice.to_vec();
所有权转换
03.Vec高级特性
a.扩容策略
容量不足时扩容
通常翻倍
减少重新分配
性能优化
b.内存布局
连续内存
堆分配
栈上存储指针、长度、容量
零成本抽象
c.所有权与Vec
Vec拥有元素
drop时释放所有元素
移动语义
示例：let v2 = v1; // v1失效
d.Vec与切片
Vec可以解引用为切片
自动Deref
示例：fn foo(s: &[i32]) { } foo(&v);
API设计
04.Vec常用方法
a.查找
contains：是否包含
binary_search：二分查找（需排序）
示例：v.contains(&5)
返回bool或Result
b.排序
sort：原地排序
sort_by：自定义比较
sort_unstable：不稳定排序（更快）
示例：v.sort();
c.去重
dedup：移除连续重复
需要先排序
示例：v.sort(); v.dedup();
原地操作
d.分割
split_at：在索引处分割
chunks：固定大小分块
windows：滑动窗口
示例：let (left, right) = v.split_at(2);
05.Vec性能考虑
a.预分配容量
避免频繁扩容
使用with_capacity
示例：let mut v = Vec::with_capacity(100);
性能优化
b.避免不必要的克隆
使用引用
借用而非所有权
示例：&v而非v.clone()
减少内存分配
c.批量操作
extend：批量添加
append：移动另一个Vec
示例：v1.extend(&v2);
更高效
d.选择合适的集合
随机访问用Vec
频繁插入删除考虑VecDeque
需要去重用HashSet
权衡时间空间
3.3 VecDeque双端队列
01.VecDeque基础
a.创建
VecDeque::new()
VecDeque::with_capacity(n)
示例：let mut deque = VecDeque::new();
环形缓冲区实现
b.两端操作
push_front：头部添加
push_back：尾部添加
pop_front：头部移除
pop_back：尾部移除
c.访问元素
索引访问：deque[0]
get：deque.get(0)
front：第一个元素
back：最后一个元素
d.使用场景
队列
双端队列
环形缓冲区
需要两端操作时
02.VecDeque特性
a.内存布局
环形缓冲区
非连续内存
头尾指针
自动环绕
b.性能特点
两端操作O(1)
中间插入O(n)
随机访问O(1)
比Vec稍慢
c.容量管理
自动扩容
reserve：预留容量
shrink_to_fit：释放多余
示例：deque.reserve(100);
d.与Vec对比
两端操作更快
内存开销稍大
随机访问稍慢
根据需求选择
03.VecDeque常用方法
a.旋转
rotate_left：左旋
rotate_right：右旋
示例：deque.rotate_left(2);
环形特性
b.分割
split_off：在索引处分割
示例：let other = deque.split_off(2);
返回新VecDeque
原地修改
c.转换
make_contiguous：整理为连续
as_slices：获取切片对
示例：let (s1, s2) = deque.as_slices();
处理环形布局
d.迭代
iter、iter_mut、into_iter
drain：移除范围内元素
示例：for item in &deque { }
与Vec类似
3.4 HashMap哈希表
01.HashMap基础
a.创建HashMap
HashMap::new()
示例：let mut map = HashMap::new();
需要导入：use std::collections::HashMap;
类型推导或显式标注
b.插入元素
insert：插入或更新
示例：map.insert(String::from("key"), 10);
返回旧值Option
键必须实现Hash和Eq
c.访问元素
get：获取引用
示例：map.get("key")
返回Option<&V>
不存在返回None
d.删除元素
remove：移除并返回值
示例：map.remove("key")
返回Option<V>
键不存在返回None
02.HashMap操作
a.更新值
insert覆盖
entry API：更灵活
示例：map.entry(key).or_insert(0);
只在不存在时插入
b.Entry API
entry：获取Entry
or_insert：不存在时插入
or_insert_with：惰性插入
and_modify：存在时修改
c.迭代
iter：迭代键值对
keys：迭代键
values：迭代值
示例：for (k, v) in &map { }
d.容量
len：元素数量
is_empty：是否为空
capacity：容量
reserve：预留容量
03.HashMap所有权
a.键值所有权
insert转移所有权
实现Copy的类型复制
示例：map.insert(key, value); // key和value被移动
注意所有权转移
b.引用作为值
可以存储引用
需要生命周期标注
示例：HashMap<&str, &i32>
引用必须有效
c.借用
get返回引用
不转移所有权
示例：let v = map.get(&key);
可以多次访问
d.克隆
clone：深拷贝
示例：let map2 = map.clone();
键值都需要实现Clone
开销较大
04.HashMap高级特性
a.自定义哈希
默认使用SipHash
可以使用其他哈希算法
示例：HashMap::with_hasher(hasher)
性能优化
b.Entry模式
避免重复查找
示例：*map.entry(key).or_insert(0) += 1;
统计词频等场景
更高效
c.容量管理
with_capacity：预分配
reserve：扩容
shrink_to_fit：收缩
减少重新哈希
d.哈希冲突
使用链表或开放寻址
自动处理
性能影响
选择好的哈希函数
05.HashMap性能
a.时间复杂度
插入：O(1)平均
查找：O(1)平均
删除：O(1)平均
最坏O(n)
b.空间复杂度
O(n)
负载因子影响
默认0.75
权衡时间空间
c.性能优化
预分配容量
选择合适的哈希
避免频繁重新哈希
批量操作
d.使用场景
键值对存储
缓存
索引
计数统计
3.5 HashSet集合
01.HashSet基础
a.创建HashSet
HashSet::new()
示例：let mut set = HashSet::new();
需要导入：use std::collections::HashSet;
元素唯一
b.插入元素
insert：添加元素
示例：set.insert(1);
返回bool（是否新插入）
重复元素不添加
c.查询
contains：是否包含
示例：set.contains(&1)
返回bool
O(1)平均
d.删除
remove：移除元素
示例：set.remove(&1)
返回bool（是否存在）
O(1)平均
02.HashSet操作
a.集合运算
union：并集
intersection：交集
difference：差集
symmetric_difference：对称差
b.迭代
iter：迭代元素
示例：for item in &set { }
无序
不保证顺序
c.容量
len：元素数量
is_empty：是否为空
capacity：容量
reserve：预留容量
d.转换
from_iter：从迭代器创建
collect：收集为HashSet
示例：let set: HashSet<_> = vec.into_iter().collect();
方便转换
03.HashSet特性
a.唯一性
自动去重
基于Hash和Eq
示例：set.insert(1); set.insert(1); // 只有一个1
用于去重
b.无序性
不保证顺序
迭代顺序不确定
需要有序用BTreeSet
哈希表特性
c.性能
插入O(1)
查找O(1)
删除O(1)
平均时间复杂度
d.内存
基于HashMap实现
值为()
内存开销类似HashMap
空间换时间
04.HashSet使用场景
a.去重
从Vec去重
示例：let set: HashSet<_> = vec.into_iter().collect();
快速去重
不保留顺序
b.成员检查
快速查找
示例：if set.contains(&item) { }
O(1)查找
大数据集高效
c.集合运算
数学集合操作
并交差
示例：let union = set1.union(&set2);
d.唯一值存储
保证唯一性
自动去重
无需手动检查
简化逻辑
3.6 BTreeMap和BTreeSet
01.BTreeMap基础
a.创建
BTreeMap::new()
示例：let mut map = BTreeMap::new();
需要导入：use std::collections::BTreeMap;
键有序
b.特性
基于B树实现
键按顺序存储
需要键实现Ord
示例：map.insert(3, "c"); map.insert(1, "a");
c.操作
insert、get、remove
与HashMap类似
示例：map.get(&key)
有序迭代
d.性能
插入O(log n)
查找O(log n)
删除O(log n)
比HashMap慢
02.BTreeSet基础
a.创建
BTreeSet::new()
示例：let mut set = BTreeSet::new();
元素有序
基于BTreeMap
b.特性
元素按顺序存储
需要实现Ord
自动排序
示例：set.insert(3); set.insert(1); // 存储为[1, 3]
c.操作
insert、contains、remove
与HashSet类似
有序迭代
范围查询
d.使用场景
需要有序
范围查询
最小最大值
排序输出
03.有序集合特性
a.范围操作
range：范围查询
示例：map.range(1..5)
返回迭代器
高效范围查询
b.边界查询
first_key_value：最小键值对
last_key_value：最大键值对
pop_first：移除最小
pop_last：移除最大
c.分割
split_off：在键处分割
示例：let right = map.split_off(&5);
保持有序
O(log n)
d.有序迭代
iter按顺序
keys、values有序
示例：for (k, v) in &map { } // 按键排序
确定性顺序
04.选择合适的集合
a.HashMap vs BTreeMap
HashMap：无序，O(1)
BTreeMap：有序，O(log n)
需要有序选BTreeMap
性能优先选HashMap
b.HashSet vs BTreeSet
HashSet：无序，O(1)
BTreeSet：有序，O(log n)
类似Map的选择
根据需求权衡
c.Vec vs VecDeque
Vec：尾部操作
VecDeque：两端操作
随机访问Vec更快
队列用VecDeque
d.性能考虑
访问模式
数据规模
内存限制
实测对比
3.7 迭代器
01.迭代器基础
a.Iterator trait
核心方法：next
返回Option<Item>
示例：let mut iter = vec.iter();
惰性求值
b.三种迭代
iter：不可变引用
iter_mut：可变引用
into_iter：消耗集合
示例：for item in &vec { }
c.for循环
自动调用into_iter
示例：for item in vec { }
语法糖
更简洁
d.手动迭代
调用next
示例：while let Some(x) = iter.next() { }
更灵活
少用
02.迭代器适配器
a.map
转换元素
示例：iter.map(|x| x * 2)
返回新迭代器
惰性求值
b.filter
过滤元素
示例：iter.filter(|x| x % 2 == 0)
保留满足条件的
惰性求值
c.take和skip
take：取前n个
skip：跳过前n个
示例：iter.take(5)
组合使用
d.chain
连接迭代器
示例：iter1.chain(iter2)
顺序迭代
惰性求值
03.消费器
a.collect
收集为集合
示例：iter.collect::<Vec<_>>()
需要指定类型
常用消费器
b.fold
累积计算
示例：iter.fold(0, |acc, x| acc + x)
类似reduce
灵活强大
c.for_each
遍历执行
示例：iter.for_each(|x| println!("{}", x))
消耗迭代器
副作用操作
d.count、sum、max、min
聚合操作
示例：iter.sum()
消耗迭代器
返回结果
04.迭代器组合
a.链式调用
多个适配器组合
示例：iter.filter().map().collect()
惰性求值
高效
b.flat_map
映射并展平
示例：iter.flat_map(|x| vec![x, x])
处理嵌套
常用模式
c.zip
配对迭代
示例：iter1.zip(iter2)
同时迭代多个
返回元组
d.enumerate
带索引迭代
示例：iter.enumerate()
返回(index, item)
常用模式
05.自定义迭代器
a.实现Iterator
定义Item类型
实现next方法
示例：impl Iterator for MyIter { type Item = i32; }
自定义迭代逻辑
b.IntoIterator
转换为迭代器
for循环调用
示例：impl IntoIterator for MyType { }
集合类型必须实现
c.迭代器状态
保存迭代位置
示例：struct MyIter { current: usize }
可变状态
next修改状态
d.无限迭代器
永不结束
示例：std::iter::repeat(5)
配合take使用
特殊场景
06.迭代器性能
a.零成本抽象
编译优化
与手写循环性能相当
示例：iter.map().filter()优化为单次遍历
推荐使用
b.惰性求值
不立即计算
组合多个操作
最后消费时执行
减少中间分配
c.避免collect
尽量延迟collect
链式操作
示例：iter.filter().map()而非iter.filter().collect().iter().map()
性能优化
d.选择合适的方法
sum vs fold
any vs find
根据场景选择
性能差异
4 函数与闭包
4.1 函数高级特性
01.函数指针
a.fn类型
函数指针类型
示例：let f: fn(i32) -> i32 = add;
可以存储和传递
零大小类型
b.函数作为参数
接受函数指针
示例：fn apply(f: fn(i32) -> i32, x: i32) -> i32 { f(x) }
高阶函数
函数式编程
c.函数作为返回值
返回函数指针
示例：fn get_func() -> fn(i32) -> i32 { add }
工厂模式
策略模式
d.函数指针与闭包
fn实现Fn trait
可以传递给接受Fn的函数
示例：iter.map(add)
灵活使用
02.泛型函数
a.类型参数
使用<T>声明
示例：fn largest<T>(list: &[T]) -> &T
编译期单态化
零成本抽象
b.特征约束
限制类型参数
示例：fn largest<T: PartialOrd>(list: &[T]) -> &T
确保类型能力
编译期检查
c.多个类型参数
多个泛型
示例：fn foo<T, U>(x: T, y: U)
灵活组合
类型推导
d.生命周期参数
泛型生命周期
示例：fn longest<'a>(x: &'a str, y: &'a str) -> &'a str
引用有效性
编译器检查
03.方法
a.定义方法
impl块中定义
第一个参数是self
示例：impl Point { fn distance(&self) -> f64 { } }
面向对象风格
b.self参数
&self：不可变借用
&mut self：可变借用
self：获取所有权
示例：fn consume(self) { }
c.关联函数
不接受self
示例：impl Point { fn new(x: f64, y: f64) -> Point { } }
使用::调用
构造函数模式
d.方法链
返回self
示例：builder.set_x(1).set_y(2).build()
流畅接口
构建器模式
04.发散函数
a.永不返回
返回类型!
示例：fn forever() -> ! { loop { } }
类型系统底类型
可以转换为任意类型
b.使用场景
panic!
exit
无限循环
示例：fn exit(code: i32) -> ! { std::process::exit(code) }
c.类型推导
!可以强制为任意类型
示例：let x: i32 = panic!();
编译器特殊处理
类型系统完整性
d.实际应用
错误处理
程序终止
不可达代码
类型系统辅助
05.const fn
a.编译期函数
const fn关键字
示例：const fn add(x: i32, y: i32) -> i32 { x + y }
编译期求值
用于常量
b.限制
不能调用非const fn
不能使用堆分配
功能受限
逐步放宽
c.使用场景
常量计算
数组长度
示例：const LEN: usize = add(5, 10);
编译期优化
d.const泛型
编译期常量参数
示例：fn foo<const N: usize>()
数组长度等
高级特性
4.2 闭包基础
01.闭包语法
a.基本语法
|参数| 表达式
示例：let add = |x, y| x + y;
类型推导
简洁语法
b.类型标注
可选的类型标注
示例：let add = |x: i32, y: i32| -> i32 { x + y };
明确类型
提高可读性
c.多行闭包
使用{}
示例：let f = |x| { let y = x + 1; y * 2 };
复杂逻辑
多条语句
d.无参数闭包
空参数列表
示例：let f = || 42;
延迟计算
常用模式
02.捕获环境
a.捕获变量
闭包可以捕获外部变量
示例：let x = 5; let f = || x + 1;
形成闭包
区别于函数
b.捕获方式
不可变借用
可变借用
移动所有权
编译器自动选择
c.move关键字
强制移动捕获
示例：let f = move || x + 1;
转移所有权
线程间传递
d.捕获规则
最小权限原则
优先不可变借用
需要时可变借用
必要时移动
03.闭包类型推导
a.自动推导
编译器推导参数和返回类型
示例：let f = |x| x + 1; // 从使用推导
首次使用确定类型
后续必须一致
b.类型固化
第一次调用确定类型
示例：let f = |x| x + 1; f(5); // f的类型固定为i32 -> i32
不能改变
类型安全
c.多态限制
每个闭包唯一类型
不能存储不同闭包
示例：let v = vec![|x| x + 1, |x| x * 2]; // 错误
需要trait对象
d.显式标注
避免歧义
提高可读性
示例：let f: fn(i32) -> i32 = |x| x + 1;
文档作用
04.闭包作为参数
a.Fn trait
不可变借用捕获
示例：fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 { f(x) }
可以多次调用
最常用
b.FnMut trait
可变借用捕获
示例：fn apply<F: FnMut(i32) -> i32>(mut f: F, x: i32)
可以修改捕获变量
可以多次调用
c.FnOnce trait
移动捕获
示例：fn apply<F: FnOnce(i32) -> i32>(f: F, x: i32)
只能调用一次
消耗闭包
d.trait继承关系
Fn: FnMut: FnOnce
Fn最严格
FnOnce最宽松
选择合适的trait
4.3 闭包高级特性
01.闭包作为返回值
a.impl Trait语法
返回实现trait的类型
示例：fn get_adder() -> impl Fn(i32) -> i32 { |x| x + 1 }
隐藏具体类型
简化签名
b.Box<dyn Trait>
trait对象
示例：fn get_func() -> Box<dyn Fn(i32) -> i32> { Box::new(|x| x + 1) }
堆分配
运行时多态
c.生命周期问题
捕获引用需要生命周期
示例：fn get_func<'a>(x: &'a i32) -> impl Fn() -> i32 + 'a
确保引用有效
编译器检查
d.move闭包
转移所有权
示例：fn get_func() -> impl Fn() -> i32 { let x = 5; move || x }
避免悬垂引用
常用模式
02.闭包与迭代器
a.map使用闭包
转换元素
示例：iter.map(|x| x * 2)
惰性求值
链式调用
b.filter使用闭包
过滤元素
示例：iter.filter(|x| x % 2 == 0)
保留满足条件
组合使用
c.fold使用闭包
累积计算
示例：iter.fold(0, |acc, x| acc + x)
强大灵活
自定义聚合
d.闭包捕获与性能
避免不必要的捕获
考虑clone成本
使用引用
性能优化
03.闭包与所有权
a.Fn闭包
不可变借用
可以多次调用
示例：let f = || println!("{}", x);
最常用
b.FnMut闭包
可变借用
可以修改捕获
示例：let mut f = || { x += 1; };
需要mut
c.FnOnce闭包
移动所有权
只能调用一次
示例：let f = || { drop(x); };
消耗值
d.自动推导
编译器选择最小权限
根据闭包体推导
示例：|| x // Fn，|| x + 1 // Fn，|| drop(x) // FnOnce
类型安全
04.闭包性能
a.零成本抽象
编译器内联
无运行时开销
示例：iter.map(|x| x * 2)优化为循环
性能等同手写
b.捕获开销
捕获变量存储在闭包中
按需捕获
示例：大结构体考虑引用
减少内存
c.trait对象开销
Box<dyn Fn>有虚表
动态分发
堆分配
性能损失
d.优化建议
优先impl Trait
避免不必要的捕获
使用引用
内联闭包
05.闭包模式
a.惰性求值
延迟计算
示例：let expensive = || heavy_computation();
按需调用
性能优化
b.回调函数
事件处理
示例：button.on_click(|| println!("clicked"));
异步编程
常用模式
c.自定义迭代器
实现Iterator
使用闭包
示例：struct Map<I, F> { iter: I, f: F }
组合模式
d.构建器模式
配置对象
示例：builder.with_callback(|| { })
流畅接口
灵活配置
4.4 函数式编程
01.函数式编程概念
a.不可变性
优先不可变数据
示例：let x = 5; // 不可变
函数式核心
并发安全
b.纯函数
无副作用
相同输入相同输出
示例：fn add(x: i32, y: i32) -> i32 { x + y }
易测试
c.高阶函数
接受或返回函数
示例：fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32
抽象模式
代码复用
d.函数组合
组合多个函数
示例：let f = |x| g(h(x));
模块化
声明式
02.常用函数式模式
a.map模式
转换数据
示例：vec.iter().map(|x| x * 2).collect()
保持结构
惰性求值
b.filter模式
筛选数据
示例：vec.iter().filter(|x| x % 2 == 0).collect()
保留满足条件
组合使用
c.reduce/fold模式
聚合数据
示例：vec.iter().fold(0, |acc, x| acc + x)
累积计算
灵活强大
d.链式调用
组合多个操作
示例：iter.filter().map().collect()
声明式
可读性高
03.Option和Result
a.Option函数式方法
map：转换Some值
and_then：链式Option
示例：opt.map(|x| x * 2).unwrap_or(0)
避免if-let
b.Result函数式方法
map：转换Ok值
and_then：链式Result
示例：result.map(|x| x * 2).unwrap_or(0)
错误处理
c.组合子
or、or_else
and、and_then
示例：opt1.or(opt2)
组合多个Option/Result
d.?运算符
简化错误传播
示例：let x = foo()?;
函数式风格
简洁优雅
04.迭代器函数式编程
a.声明式风格
描述做什么而非怎么做
示例：iter.filter(|x| x > 0).map(|x| x * 2)
可读性
意图清晰
b.惰性求值
不立即计算
组合操作
最后消费
性能优化
c.无副作用
迭代器方法纯函数
不修改原数据
返回新迭代器
安全并发
d.组合模式
多个适配器组合
示例：iter.filter().map().take().collect()
强大灵活
零成本抽象
05.函数式编程优势
a.代码简洁
减少样板代码
示例：iter.sum()而非手写循环
表达力强
易维护
b.易于测试
纯函数
无副作用
确定性
单元测试友好
c.并发安全
不可变数据
无共享状态
示例：par_iter().map()
线程安全
d.组合性
小函数组合
模块化
代码复用
灵活扩展
06.函数式编程最佳实践
a.优先使用迭代器
而非手写循环
示例：iter.filter().map()
更符合Rust风格
性能相当
b.使用组合子
Option和Result
避免unwrap
示例：opt.map().unwrap_or()
更安全
c.保持函数纯净
避免副作用
明确输入输出
示例：fn pure(x: i32) -> i32 { x * 2 }
易测试
d.适度使用
不要过度函数式
平衡可读性
命令式有时更清晰
实用主义
5 结构体与枚举
5.1 结构体定义
01.结构体基础
a.定义结构体
使用struct关键字
示例：struct Point { x: f64, y: f64 }
命名字段
类型标注
b.创建实例
字段初始化
示例：let p = Point { x: 1.0, y: 2.0 };
必须初始化所有字段
字段顺序无关
c.访问字段
点语法
示例：let x = p.x;
可变性继承
示例：let mut p = Point { x: 1.0, y: 2.0 }; p.x = 3.0;
d.字段简写
变量名与字段名相同
示例：let x = 1.0; let p = Point { x, y: 2.0 };
简化代码
常用模式
02.结构体类型
a.命名字段结构体
最常用
示例：struct User { name: String, age: u32 }
字段有名称
可读性好
b.元组结构体
匿名字段
示例：struct Color(u8, u8, u8);
按位置访问
示例：let c = Color(255, 0, 0); let r = c.0;
c.单元结构体
无字段
示例：struct Unit;
标记类型
实现trait
d.选择合适类型
多字段用命名结构体
少量字段用元组结构体
标记用单元结构体
根据语义选择
03.结构体更新语法
a.基于现有实例
..语法
示例：let p2 = Point { x: 3.0, ..p1 };
复制其他字段
简化创建
b.所有权转移
非Copy字段会移动
示例：let u2 = User { name: String::from("Bob"), ..u1 }; // u1.age可用，u1.name不可用
注意所有权
部分移动
c.使用场景
配置对象
默认值
示例：Config { port: 8080, ..Default::default() }
构建器模式
d.限制
必须在最后
只能使用一次
示例：Point { x: 1.0, ..p1, ..p2 } // 错误
语法规则
04.结构体所有权
a.拥有数据
结构体拥有字段
示例：struct User { name: String }
drop时释放
完整所有权
b.借用数据
字段可以是引用
示例：struct User<'a> { name: &'a str }
需要生命周期
不拥有数据
c.生命周期标注
引用字段需要生命周期
示例：struct Excerpt<'a> { part: &'a str }
确保引用有效
编译器检查
d.选择策略
拥有数据更简单
借用数据更灵活
根据需求选择
权衡利弊
05.结构体内存布局
a.字段对齐
编译器自动对齐
可能有填充
示例：struct S { a: u8, b: u32 } // 可能占8字节
性能优化
b.repr属性
控制布局
示例：#[repr(C)] // C兼容布局
FFI使用
#[repr(packed)]紧凑布局
c.大小计算
std::mem::size_of
示例：size_of::<Point>()
包含填充
对齐要求
d.零大小类型
无字段或全是ZST
示例：struct Unit;
不占内存
类型标记
5.2 方法与关联函数
01.方法定义
a.impl块
实现方法
示例：impl Point { fn distance(&self) -> f64 { } }
self参数
面向对象风格
b.self参数
&self：不可变借用
&mut self：可变借用
self：获取所有权
示例：fn reset(&mut self) { self.x = 0.0; }
c.方法调用
点语法
示例：p.distance()
自动借用/解引用
简洁语法
d.多个impl块
可以有多个
示例：impl Point { } impl Point { }
组织代码
条件编译
02.关联函数
a.定义
不接受self
示例：impl Point { fn new(x: f64, y: f64) -> Point { } }
使用::调用
构造函数
b.构造函数模式
new函数
示例：Point::new(1.0, 2.0)
初始化对象
常用约定
c.工厂方法
创建不同变体
示例：Point::origin() // (0, 0)
语义化构造
多种创建方式
d.其他关联函数
类型相关的函数
示例：String::from("hello")
不需要实例
命名空间
03.方法链
a.返回self
返回&self或&mut self
示例：fn set_x(&mut self, x: f64) -> &mut Self { self.x = x; self }
链式调用
流畅接口
b.构建器模式
配置对象
示例：Builder::new().set_x(1.0).set_y(2.0).build()
可读性好
灵活配置
c.消费self
返回新对象
示例：fn with_x(mut self, x: f64) -> Self { self.x = x; self }
转移所有权
不可变链
d.选择合适方式
配置用&mut self
转换用self
查询用&self
根据语义
04.自动引用和解引用
a.方法调用自动借用
编译器自动添加&、&mut或*
示例：p.distance() // 自动&p
简化代码
智能处理
b.解引用强制转换
Deref trait
示例：String自动转&str
方法查找
类型转换
c.方法查找顺序
值本身
&T
&mut T
解引用后的类型
d.优势
简洁语法
自动处理
类型安全
零成本
05.泛型结构体
a.类型参数
示例：struct Point<T> { x: T, y: T }
灵活类型
代码复用
b.泛型方法
示例：impl<T> Point<T> { fn x(&self) -> &T { &self.x } }
适用所有T
通用实现
c.特定类型实现
示例：impl Point<f64> { fn distance(&self) -> f64 { } }
只对f64实现
特化方法
d.约束泛型
示例：impl<T: Display> Point<T> { }
限制类型
确保能力
5.3 枚举
01.枚举定义
a.基本枚举
使用enum关键字
示例：enum Direction { North, South, East, West }
变体列表
类型安全
b.带数据的枚举
变体可以携带数据
示例：enum Message { Quit, Move { x: i32, y: i32 }, Write(String) }
不同类型数据
灵活强大
c.创建枚举值
使用变体名
示例：let msg = Message::Write(String::from("hello"));
命名空间
类型推导
d.枚举与结构体
枚举是和类型
结构体是积类型
示例：enum可以是A或B，struct同时有A和B
不同用途
02.Option枚举
a.定义
标准库枚举
示例：enum Option<T> { Some(T), None }
表示可能的值
无空指针
b.使用Option
返回可能失败的值
示例：fn find(v: &[i32], target: i32) -> Option<usize>
显式处理None
类型安全
c.Option方法
unwrap：取值或panic
unwrap_or：提供默认值
map：转换Some值
示例：opt.unwrap_or(0)
d.?运算符
简化Option处理
示例：let x = opt?;
自动传播None
函数式风格
03.Result枚举
a.定义
错误处理枚举
示例：enum Result<T, E> { Ok(T), Err(E) }
表示成功或失败
携带错误信息
b.使用Result
可能失败的操作
示例：fn parse(s: &str) -> Result<i32, ParseIntError>
显式错误处理
强制处理
c.Result方法
unwrap：取值或panic
expect：带消息panic
unwrap_or：默认值
示例：result.unwrap_or(0)
d.?运算符
错误传播
示例：let x = parse(s)?;
自动转换错误
简化代码
04.枚举方法
a.impl枚举
为枚举实现方法
示例：impl Message { fn call(&self) { } }
面向对象风格
封装行为
b.关联函数
构造函数
示例：impl Message { fn new_quit() -> Self { Message::Quit } }
工厂方法
语义化
c.模式匹配方法
内部使用match
示例：fn process(&self) { match self { ... } }
处理不同变体
类型安全
d.泛型枚举方法
示例：impl<T> Option<T> { fn is_some(&self) -> bool { } }
通用实现
标准库模式
05.枚举内存布局
a.标签联合
存储判别式和数据
示例：enum占用最大变体大小+判别式
内存对齐
空间优化
b.判别式
标识当前变体
通常是整数
示例：as转换获取
内部实现
c.空指针优化
Option<&T>等大小与&T相同
使用空指针表示None
零成本抽象
编译器优化
d.大小计算
size_of::<Enum>()
最大变体+判别式
对齐要求
内存效率
5.4 模式匹配
01.match表达式
a.基本语法
match value { pattern => expression, }
示例：match x { 1 => "one", 2 => "two", _ => "other" }
穷尽性检查
编译期保证
b.匹配枚举
解构枚举变体
示例：match msg { Message::Quit => {}, Message::Move { x, y } => {} }
提取数据
类型安全
c.匹配守卫
额外条件
示例：match x { n if n > 0 => "positive", _ => "other" }
更灵活
复杂逻辑
d.绑定模式
@绑定
示例：match x { n @ 1..=5 => println!("{}", n), _ => {} }
同时匹配和绑定
访问值
02.解构模式
a.解构结构体
提取字段
示例：let Point { x, y } = p;
简化访问
可以重命名
b.解构元组
按位置提取
示例：let (x, y, z) = tuple;
忽略值用_
嵌套解构
c.解构枚举
匹配变体
示例：if let Some(x) = opt { }
提取内部值
常用模式
d.嵌套解构
多层解构
示例：match opt { Some(Point { x, y }) => {} }
复杂模式
强大灵活
03.if let和while let
a.if let
简化单分支match
示例：if let Some(x) = opt { println!("{}", x); }
更简洁
常用模式
b.else分支
处理其他情况
示例：if let Some(x) = opt { } else { }
可选else
灵活使用
c.while let
循环匹配
示例：while let Some(x) = iter.next() { }
迭代模式
简化代码
d.使用场景
单分支匹配用if let
多分支用match
循环迭代用while let
根据需求选择
04.模式类型
a.字面量模式
匹配具体值
示例：match x { 1 => {}, 2 => {} }
精确匹配
常用模式
b.范围模式
匹配范围
示例：match x { 1..=5 => {}, 6..=10 => {} }
包含边界
数值范围
c.通配符模式
_匹配任意值
示例：match x { _ => {} }
忽略值
默认分支
d.引用模式
匹配引用
示例：match &value { &Some(ref x) => {} }
避免移动
ref关键字
05.模式匹配最佳实践
a.穷尽性
必须覆盖所有情况
使用_或具体模式
示例：match x { 1 => {}, _ => {} }
编译器检查
b.优先使用match
而非if-else链
更清晰
编译器优化
类型安全
c.使用if let简化
单分支时
示例：if let Some(x) = opt { }
避免冗余
可读性
d.利用解构
简化代码
示例：let Point { x, y } = p;
直接访问
减少中间变量
5.5 派生trait
01.常用派生
a.Debug
调试输出
示例：#[derive(Debug)]
{:?}格式化
开发必备
b.Clone
深拷贝
示例：#[derive(Clone)]
.clone()方法
所有字段需Clone
c.Copy
按位复制
示例：#[derive(Copy, Clone)]
隐式复制
需要Clone
d.PartialEq和Eq
相等比较
示例：#[derive(PartialEq, Eq)]
==和!=
所有字段需实现
02.其他派生
a.PartialOrd和Ord
比较排序
示例：#[derive(PartialOrd, Ord)]
<、>等
需要PartialEq
b.Hash
哈希
示例：#[derive(Hash)]
HashMap键
需要Eq
c.Default
默认值
示例：#[derive(Default)]
Default::default()
字段需Default
d.组合派生
多个trait
示例：#[derive(Debug, Clone, PartialEq)]
常用组合
简化代码
03.派生限制
a.字段要求
所有字段必须实现
示例：struct包含不实现Clone的字段不能派生Clone
传递性
编译检查
b.泛型派生
泛型参数需约束
示例：#[derive(Clone)] struct S<T: Clone>(T);
自动添加约束
类型安全
c.自定义实现
派生不满足需求时
手动实现trait
示例：impl Clone for MyType { }
更灵活
d.选择合适方式
简单情况派生
复杂逻辑手动实现
权衡利弊
代码清晰
6 特征与多态
6.1 Trait定义与实现
01.Trait基础
a.定义trait
使用trait关键字
示例：trait Summary { fn summarize(&self) -> String; }
方法签名
行为抽象
b.实现trait
impl Trait for Type
示例：impl Summary for Article { fn summarize(&self) -> String { } }
提供具体实现
类型实现行为
c.默认实现
trait中提供默认方法
示例：trait Summary { fn summarize(&self) -> String { String::from("...") } }
可以覆盖
代码复用
d.trait方法调用
点语法
示例：article.summarize()
需要trait在作用域
use导入
02.Trait约束
a.泛型约束
限制类型参数
示例：fn notify<T: Summary>(item: &T)
确保类型能力
编译期检查
b.多个约束
使用+连接
示例：fn notify<T: Summary + Display>(item: &T)
同时满足多个trait
灵活组合
c.where子句
复杂约束
示例：fn foo<T, U>(t: &T, u: &U) where T: Display, U: Clone
提高可读性
清晰表达
d.impl Trait语法
简化返回类型
示例：fn returns_summarizable() -> impl Summary
隐藏具体类型
简洁语法
03.关联类型
a.定义关联类型
trait中声明
示例：trait Iterator { type Item; }
实现时指定
示例：impl Iterator for Counter { type Item = u32; }
b.与泛型的区别
关联类型每个实现唯一
泛型可以多个实现
示例：Iterator只能有一个Item类型
简化trait使用
c.使用场景
迭代器Item
运算符Output
转换Target
避免类型参数过多
d.优势
简化trait定义
减少类型参数
更清晰的API
类型推导友好
04.Trait继承
a.超trait
trait继承trait
示例：trait OutlinePrint: Display { }
要求实现Display
组合能力
b.多重继承
继承多个trait
示例：trait A: B + C { }
组合多个能力
灵活设计
c.使用场景
扩展已有trait
组合多个能力
示例：trait Printable: Display + Debug { }
语义化约束
d.实现要求
必须先实现超trait
编译器检查
示例：impl OutlinePrint需要先impl Display
确保能力
05.孤儿规则
a.规则内容
trait或类型至少一个在当前crate
示例：不能为Vec<T>实现Display
避免冲突
一致性保证
b.绕过方法
新类型模式
示例：struct Wrapper(Vec<String>);
包装外部类型
实现外部trait
c.原因
避免上游破坏
保证一致性
示例：两个crate都为Vec实现Display会冲突
类型系统安全
d.最佳实践
优先实现自己的trait
必要时使用新类型
遵守规则
避免冲突
6.2 Trait对象
01.Trait对象基础
a.动态分发
运行时多态
示例：Box<dyn Summary>
虚表调用
类型擦除
b.创建trait对象
使用dyn关键字
示例：let obj: &dyn Summary = &article;
引用或智能指针
不能直接使用
c.对象安全
trait必须对象安全
方法不能返回Self
不能有泛型方法
示例：trait Clone不是对象安全
d.使用场景
异构集合
运行时多态
示例：Vec<Box<dyn Draw>>
插件系统
02.静态分发vs动态分发
a.静态分发
泛型+trait约束
示例：fn notify<T: Summary>(item: &T)
编译期单态化
零成本抽象
b.动态分发
trait对象
示例：fn notify(item: &dyn Summary)
运行时虚表
有性能开销
c.性能对比
静态分发更快
动态分发更灵活
代码大小不同
权衡选择
d.选择建议
性能优先用静态
灵活性优先用动态
具体类型已知用静态
异构集合用动态
03.对象安全规则
a.不能返回Self
Self大小未知
示例：fn clone(&self) -> Self // 不对象安全
trait对象无法使用
编译器限制
b.不能有泛型方法
单态化冲突
示例：fn foo<T>(&self) // 不对象安全
虚表无法表示
类型系统限制
c.不能有关联函数
除非有where Self: Sized
示例：fn new() -> Self // 不对象安全
需要具体类型
对象安全约束
d.检查对象安全
编译器自动检查
错误提示清晰
示例：the trait cannot be made into an object
遵守规则
04.Trait对象内存布局
a.胖指针
数据指针+虚表指针
示例：&dyn Trait占16字节（64位）
两个指针大小
运行时信息
b.虚表
方法指针表
drop、size、align信息
运行时查找
动态分发机制
c.性能开销
间接调用
无法内联
示例：比静态分发慢
可预测性差
d.优化建议
避免热路径
批量调用
考虑静态分发
性能测试
05.Trait对象使用模式
a.异构集合
存储不同类型
示例：Vec<Box<dyn Draw>>
统一接口
灵活扩展
b.插件系统
动态加载
示例：load_plugin() -> Box<dyn Plugin>
运行时扩展
解耦设计
c.回调函数
存储闭包
示例：Box<dyn Fn()>
灵活回调
事件系统
d.状态模式
不同状态实现
示例：Box<dyn State>
状态转换
设计模式
6.3 标准Trait
01.Debug和Display
a.Debug trait
调试输出
示例：#[derive(Debug)] 或手动实现
{:?}格式化
开发必备
b.Display trait
用户友好输出
示例：impl Display for Point { }
{}格式化
手动实现
c.区别
Debug用于调试
Display用于展示
Debug可派生
Display需手动
d.使用场景
Debug：开发调试
Display：用户界面
示例：println!("{:?}", point); println!("{}", point);
根据需求选择
02.Clone和Copy
a.Clone trait
显式深拷贝
示例：let y = x.clone();
可能昂贵
手动调用
b.Copy trait
隐式按位复制
示例：let y = x; // x仍然有效
必须是简单类型
需要Clone
c.实现要求
Copy需要所有字段都Copy
Clone可以自定义
示例：#[derive(Copy, Clone)]
类型约束
d.选择建议
简单类型实现Copy
复杂类型只实现Clone
避免意外复制
性能考虑
03.PartialEq和Eq
a.PartialEq
部分等价关系
示例：impl PartialEq for Point { }
==和!=
可能不满足传递性
b.Eq
完全等价关系
示例：impl Eq for Point { }
标记trait
满足传递性
c.浮点数问题
NaN != NaN
只能实现PartialEq
示例：f64实现PartialEq但不实现Eq
数学特性
d.派生
#[derive(PartialEq, Eq)]
自动实现
字段逐一比较
简化代码
04.PartialOrd和Ord
a.PartialOrd
部分顺序
示例：impl PartialOrd for Point { }
<、>、<=、>=
可能无法比较
b.Ord
全序
示例：impl Ord for Point { }
任意两值可比
需要Eq
c.cmp方法
返回Ordering
示例：fn cmp(&self, other: &Self) -> Ordering
Less、Equal、Greater
排序基础
d.使用场景
排序
BTreeMap键
示例：vec.sort()
需要Ord
05.Hash
a.Hash trait
计算哈希值
示例：impl Hash for Point { }
HashMap键
需要Eq
b.实现要求
相等的值哈希相同
示例：a == b => hash(a) == hash(b)
一致性保证
正确性要求
c.派生
#[derive(Hash)]
自动实现
字段组合哈希
常用方式
d.自定义哈希
特殊需求
性能优化
示例：只哈希部分字段
小心使用
06.Default
a.Default trait
默认值
示例：impl Default for Point { fn default() -> Self { } }
Default::default()
初始化
b.派生
#[derive(Default)]
字段都需Default
示例：数值类型默认0
简化代码
c.使用场景
构造函数
配置对象
示例：Config::default()
常用模式
d.与new的区别
Default无参数
new可以有参数
Default是trait
new是约定
6.4 运算符重载
01.算术运算符
a.Add trait
+运算符
示例：impl Add for Point { type Output = Point; }
定义加法
返回类型灵活
b.Sub、Mul、Div
-、*、/运算符
示例：impl Sub for Point { }
类似Add
数学运算
c.关联类型Output
指定结果类型
示例：type Output = Self;
可以不同于Self
灵活设计
d.使用示例
let p3 = p1 + p2;
自然语法
类型安全
编译期检查
02.比较运算符
a.PartialEq
==和!=
示例：impl PartialEq for Point { }
自定义相等
逻辑判断
b.PartialOrd
<、>、<=、>=
示例：impl PartialOrd for Point { }
自定义比较
排序逻辑
c.自定义比较逻辑
按特定字段
示例：只比较x坐标
语义化
灵活实现
d.注意事项
保持一致性
满足数学性质
示例：a == b且b == c则a == c
正确性
03.索引运算符
a.Index trait
[]读取
示例：impl Index<usize> for MyVec { type Output = i32; }
自定义索引
类数组访问
b.IndexMut trait
[]写入
示例：impl IndexMut<usize> for MyVec { }
可变索引
修改元素
c.索引类型
可以不是usize
示例：impl Index<&str> for HashMap { }
灵活索引
语义化
d.panic处理
越界panic
或返回Option
示例：get方法返回Option
安全考虑
04.其他运算符
a.Deref和DerefMut
*解引用
示例：impl Deref for MyBox<T> { type Target = T; }
智能指针
自动解引用
b.Drop
析构
示例：impl Drop for MyType { fn drop(&mut self) { } }
资源清理
RAII模式
c.Fn、FnMut、FnOnce
()调用
示例：impl FnOnce() for MyCallable { }
可调用对象
闭包trait
d.From和Into
类型转换
示例：impl From<i32> for MyType { }
Into自动实现
转换trait
05.运算符重载最佳实践
a.保持直观
符合数学或逻辑直觉
示例：+用于相加，不用于其他
避免混淆
可读性
b.保持一致性
相关运算符一起实现
示例：实现Add也实现AddAssign
完整性
用户期望
c.考虑性能
避免不必要的复制
示例：返回引用或使用move
优化开销
效率优先
d.文档说明
清晰说明行为
示例：/// Adds two points
避免误用
API友好
6.5 Trait高级特性
01.完全限定语法
a.消除歧义
多个trait同名方法
示例：<Type as Trait>::method()
明确指定trait
类型安全
b.关联函数调用
不是方法
示例：<Dog as Animal>::baby_name()
无self参数
完全限定
c.使用场景
名称冲突
关联函数
示例：多个trait都有new
明确意图
d.语法
<Type as Trait>::item
完整形式
清晰明确
避免歧义
02.新类型模式
a.包装类型
struct Wrapper(Vec<String>);
示例：为外部类型实现外部trait
绕过孤儿规则
类型安全
b.零成本抽象
#[repr(transparent)]
内存布局相同
示例：运行时无开销
编译期检查
c.使用场景
实现外部trait
类型区分
示例：Meters(f64)和Kilometers(f64)
语义化
d.Deref实现
自动解引用
示例：impl Deref for Wrapper { type Target = Vec<String>; }
访问内部方法
便利性
03.条件trait实现
a.泛型约束实现
只为满足条件的类型实现
示例：impl<T: Display> ToString for T { }
标准库模式
灵活扩展
b.blanket实现
为所有满足条件的类型
示例：impl<T> MyTrait for T where T: OtherTrait { }
批量实现
代码复用
c.特化
为特定类型优化
示例：impl MyTrait for i32 { } // 特殊实现
性能优化
特殊处理
d.注意事项
避免冲突
保持一致性
示例：特化实现应与通用实现语义一致
正确性
7 模块与包管理
7.1 模块系统
01.模块基础
a.定义模块
使用mod关键字
示例：mod network { }
组织代码
命名空间
b.嵌套模块
模块内定义模块
示例：mod network { mod server { } }
层次结构
逻辑分组
c.模块路径
绝对路径：crate::
相对路径：self::、super::
示例：crate::network::server
访问模块项
d.文件模块
mod network;声明
network.rs或network/mod.rs
示例：src/network.rs
代码组织
02.可见性
a.私有性默认
默认私有
示例：fn private_function() { }
封装实现
信息隐藏
b.pub关键字
公开项
示例：pub fn public_function() { }
导出API
模块接口
c.pub(crate)
crate内可见
示例：pub(crate) fn internal() { }
内部API
限制范围
d.pub(in path)
指定路径可见
示例：pub(in crate::network) fn helper() { }
精确控制
灵活可见性
03.use关键字
a.引入路径
简化访问
示例：use std::collections::HashMap;
避免重复
提高可读性
b.嵌套路径
组合引入
示例：use std::{cmp::Ordering, io};
简化多个引入
清晰组织
c.as重命名
避免冲突
示例：use std::io::Result as IoResult;
语义化
消除歧义
d.pub use
重导出
示例：pub use self::network::connect;
简化API
外观模式
04.模块树
a.crate根
lib.rs或main.rs
模块树根
示例：crate::module
入口点
b.模块层次
树形结构
父子关系
示例：crate::a::b::c
逻辑组织
c.路径解析
从根或当前模块
示例：crate::、super::、self::
相对绝对
灵活访问
d.模块拆分
单文件或目录
示例：mod.rs作为目录模块
代码组织
可维护性
05.模块最佳实践
a.逻辑分组
相关功能组织在一起
示例：network模块包含连接、协议等
清晰结构
易于理解
b.最小化公开
只公开必要的API
示例：内部实现保持私有
封装性
稳定接口
c.扁平化导出
pub use重导出
示例：简化深层路径
用户友好
API设计
d.文档注释
模块级文档
示例：//! Module documentation
说明用途
使用指南
7.2 包和Crate
01.包基础
a.包定义
Cargo.toml定义
包含一个或多个crate
示例：package with lib and bin
项目单位
b.Crate类型
库crate：lib.rs
二进制crate：main.rs
示例：一个包可以有多个bin
不同用途
c.Crate根
编译入口
示例：src/lib.rs、src/main.rs
模块树根
编译单元
d.包结构
src/目录
Cargo.toml配置
示例：标准项目布局
约定优于配置
02.Cargo.toml
a.包元数据
name、version、authors
示例：[package] name = "my_project"
包信息
发布必需
b.依赖声明
[dependencies]
示例：serde = "1.0"
版本要求
依赖管理
c.dev依赖
[dev-dependencies]
示例：测试和开发依赖
不包含在发布中
开发工具
d.features
条件编译
示例：[features] default = ["std"]
可选功能
灵活配置
03.工作空间
a.工作空间定义
[workspace]
示例：members = ["crate1", "crate2"]
多包项目
共享依赖
b.成员crate
独立的包
共享Cargo.lock
示例：统一版本
依赖一致性
c.路径依赖
本地crate依赖
示例：my_crate = { path = "../my_crate" }
开发便利
模块化
d.使用场景
大型项目
多个相关包
示例：库和多个工具
代码组织
04.发布crate
a.crates.io
Rust包仓库
示例：cargo publish
公开发布
社区共享
b.版本号
语义化版本
示例：1.2.3
major.minor.patch
兼容性
c.文档
README.md
API文档
示例：cargo doc
用户指南
d.许可证
LICENSE文件
示例：MIT、Apache-2.0
法律要求
开源协议
05.依赖管理
a.版本要求
^1.2.3：兼容版本
~1.2.3：补丁版本
示例：serde = "^1.0"
语义化
b.Cargo.lock
锁定版本
示例：确保可重现构建
版本一致
团队协作
c.更新依赖
cargo update
示例：更新到兼容版本
维护更新
安全补丁
d.依赖冲突
版本冲突解决
示例：统一版本要求
兼容性
构建成功
7.3 测试
01.单元测试
a.测试模块
#[cfg(test)]
示例：#[cfg(test)] mod tests { }
测试代码
条件编译
b.测试函数
#[test]
示例：#[test] fn it_works() { }
测试标记
自动发现
c.断言宏
assert!、assert_eq!、assert_ne!
示例：assert_eq!(2 + 2, 4);
验证结果
失败panic
d.运行测试
cargo test
示例：运行所有测试
并行执行
测试报告
02.集成测试
a.tests目录
tests/integration_test.rs
示例：独立的测试文件
测试公共API
黑盒测试
b.测试组织
每个文件是独立crate
示例：tests/common/mod.rs为共享代码
模块化
代码复用
c.运行特定测试
cargo test test_name
示例：cargo test integration
过滤测试
快速验证
d.测试二进制crate
只能测试库crate
示例：main.rs逻辑移到lib.rs
可测试性
设计考虑
03.测试组织
a.测试位置
单元测试：同文件
集成测试：tests/
示例：src/lib.rs包含#[cfg(test)]
就近原则
b.私有函数测试
单元测试可以测试
示例：同模块内可访问私有
白盒测试
完整覆盖
c.测试辅助函数
setup、teardown
示例：fn setup() -> TestContext { }
代码复用
清晰组织
d.测试命名
描述性名称
示例：test_addition_works
清晰意图
可读性
04.测试属性
a.should_panic
期望panic
示例：#[test] #[should_panic]
测试错误处理
验证panic
b.ignore
忽略测试
示例：#[test] #[ignore]
临时禁用
耗时测试
c.Result返回
返回Result<(), E>
示例：#[test] fn test() -> Result<(), String> { }
使用?运算符
错误传播
d.自定义测试框架
#[cfg(test)]配置
示例：使用第三方测试框架
高级需求
灵活扩展
05.测试最佳实践
a.测试覆盖
关键路径
边界条件
示例：测试0、负数、最大值
完整性
b.独立性
测试互不依赖
示例：每个测试独立setup
并行安全
可靠性
c.可读性
清晰的测试名称
示例：test_empty_vec_returns_none
自文档化
维护性
d.快速反馈
快速测试
示例：避免耗时操作
开发效率
持续集成
7.4 文档
01.文档注释
a.///注释
项文档
示例：/// Adds two numbers
Markdown格式
生成文档
b.//!注释
模块/crate文档
示例：//! This crate provides...
文件开头
整体说明
c.文档结构
# Examples
# Panics
# Errors
示例：标准章节
d.代码示例
```rust代码块
示例：自动测试
确保正确
用户指南
02.文档生成
a.cargo doc
生成HTML文档
示例：cargo doc --open
自动打开
本地查看
b.文档测试
cargo test
示例：测试文档中的代码
保持同步
质量保证
c.文档发布
docs.rs
示例：自动发布到docs.rs
在线文档
版本管理
d.文档配置
Cargo.toml
示例：[package.metadata.docs.rs]
自定义选项
特性控制
03.文档最佳实践
a.公共API文档
所有公共项
示例：pub fn必须有文档
用户友好
API清晰
b.示例代码
实际用例
示例：完整可运行
学习曲线
快速上手
c.链接
[`item`]语法
示例：See [`HashMap`]
导航便利
关联说明
d.保持更新
代码变化同步
示例：重构后更新文档
准确性
可信度
7.5 构建配置
01.编译配置
a.profile
[profile.dev]、[profile.release]
示例：opt-level = 3
优化级别
性能调优
b.条件编译
#[cfg(feature = "...")]
示例：#[cfg(target_os = "linux")]
平台特定
可选功能
c.features
[features]
示例：default = ["std"]
功能开关
灵活配置
d.build.rs
构建脚本
示例：编译前执行
代码生成
系统集成
02.环境配置
a.环境变量
RUSTFLAGS
示例：RUSTFLAGS="-C target-cpu=native"
编译选项
性能优化
b.配置文件
.cargo/config.toml
示例：项目级配置
团队共享
一致性
c.目标平台
--target
示例：cargo build --target x86_64-pc-windows-gnu
交叉编译
多平台
d.工具链
rustup
示例：rustup default stable
版本管理
工具链切换
03.优化配置
a.LTO
链接时优化
示例：lto = true
性能提升
编译时间
b.codegen-units
并行编译
示例：codegen-units = 1
优化vs速度
权衡选择
c.panic策略
panic = "abort"
示例：减小二进制
嵌入式
特殊场景
d.strip
去除符号
示例：strip = true
减小体积
发布优化
04.依赖配置
a.patch
替换依赖
示例：[patch.crates-io]
修复bug
本地开发
b.git依赖
从git仓库
示例：my_crate = { git = "..." }
最新代码
开发版本
c.路径依赖
本地crate
示例：my_crate = { path = "../my_crate" }
开发便利
模块化
d.可选依赖
optional = true
示例：serde = { version = "1.0", optional = true }
按需引入
减少依赖
05.项目结构
a.标准布局
src/、tests/、examples/
示例：约定目录结构
清晰组织
工具支持
b.多二进制
src/bin/
示例：多个可执行文件
工具集
灵活部署
c.示例
examples/
示例：使用示例
用户学习
测试用例
d.基准测试
benches/
示例：性能测试
优化指导
回归检测
7.6 Cargo命令
01.常用命令
a.cargo build
编译项目
示例：cargo build --release
开发和发布
增量编译
b.cargo run
编译并运行
示例：cargo run -- args
快速测试
开发迭代
c.cargo test
运行测试
示例：cargo test test_name
质量保证
持续集成
d.cargo check
快速检查
示例：不生成二进制
语法检查
快速反馈
02.包管理
a.cargo new
创建项目
示例：cargo new my_project
初始化
模板生成
b.cargo add
添加依赖
示例：cargo add serde
依赖管理
版本选择
c.cargo update
更新依赖
示例：更新Cargo.lock
版本维护
安全更新
d.cargo publish
发布crate
示例：发布到crates.io
社区贡献
版本发布
03.工具命令
a.cargo fmt
代码格式化
示例：统一风格
可读性
团队协作
b.cargo clippy
代码检查
示例：最佳实践建议
质量提升
学习工具
c.cargo doc
生成文档
示例：cargo doc --open
API文档
用户指南
d.cargo bench
基准测试
示例：性能测试
优化指导
性能回归