11.2 阶段 1 语言基础与类型系统
所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈
本页目录
一、阶段定位
阶段 0 把工具链装好后,本阶段正式开始写 Rust 代码。但它不是「Rust 语法大全」——那部分你在 The Book 里能看完。本阶段聚焦的是 Rust 与 C/C++、Java、Go 在数据表示与控制流上的硬差异,这些差异决定了后面阶段 2 的所有权、阶段 3 的 trait 为什么必须这样设计:
- 不可变是默认:
let x = 5;出来的x不能再赋值,必须let mut x = 5;才能改。这与 C/Java 的「变量默认可变」完全相反。 - 没有 null,只有
Option<T>:任何「可能没有」的情况必须用Option类型表达,编译器强制你处理None。Java 的 NPE 与 Go 的 nil 这类运行时错误在 Rust 里根本编译不过。 - 穷尽性匹配:
match必须覆盖所有可能,枚举加一个变体,所有match都要改。这是「编译器帮你改代码」的开端。 String与&str是两个东西:String是堆上可变的字符串,&str是借用的切片。C/C++ 里「字符串就是 char 指针」的直觉在这里完全失效。
本阶段与前后阶段的衔接:往上承接阶段 0 的 cargo,本阶段要真正用上 cargo new、cargo test、cargo clippy;往下交给阶段 2 去解决「为什么 let s2 = s1; 之后 s1 不能再用」的所有权问题。本阶段先把「值怎么读、怎么匹配、怎么放集合里」写顺,再去解决「谁拥有这个值」。跳过所有权直接讲 trait 会卡住,跳过本阶段直接讲所有权则会让你连「一个函数长什么样」都写不顺。
「卡点」判断标准:看到下面任一现象,说明本阶段没结束——
- 看到
let x = 5;想改x时第一反应是「为什么不能改」,而不是「我要加mut」; - 写函数返回值时,第一反应是「可能返回 null」,而不是「我应当返回
Option<T>」; match写了三四个 case 就过,没意识到编译器会报「non-exhaustive patterns」;- 把
String当作&str的同义词,函数签名里混用String、&str、&String自己都讲不清区别; - 用
Vec<i32>与HashMap<K,V>时,不知道什么时候该用BTreeMap。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
能写一个带 enum、match、Option、Result 的小型 CLI,处理所有错误分支 |
cargo clippy -- -D warnings 通过;cargo test 覆盖至少 5 个分支 |
能解释 String 与 &str 的内存布局与互转代价,函数签名里优先选 &str 而不是 &String |
给定一个 String 参数,能说出改成 &str 的好处 |
能说清 Vec<T>、HashMap<K,V>、BTreeMap<K,V> 的复杂度与选取依据 |
给定「按用户 ID 查」与「按时间范围排序遍历」两种需求,分别选对容器 |
能用 if let / while let 简化只关心一个分支的匹配,知道什么时候必须用 match |
把一段啰嗦的 match 改写成 if let 且语义不变 |
能写出 Debug 与 Display 的区别,并在自定义类型上派生 Debug、手实现 Display |
println!("{:?}", x) 与 println!("{}", x) 输出符合预期 |
能解释 debug 与 release 下整数溢出行为差异,并在生产代码里用 checked_add / wrapping_add 选语义 |
写一段 i32::MAX + 1 在两个 profile 下分别跑,观察差异 |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 60 小时。其中读文档 15 小时、写代码 40 小时、复盘 5 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 70 小时。按「一个模块两天」节奏排。
学时分配建议:变量与可变性 10%、标量与复合类型 10%、控制流与穷尽性匹配 20%、枚举与 Option/Result 15%、结构体与 impl 15%、模块与可见性 10%、String/&str/切片 10%、集合选取 5%、格式化与溢出 5%。枚举与 Option/Result 是面试重灾区,时间给足。
三、先修自检
进入本阶段前,逐条自检:
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 工具链可用 | rustup show 显示 stable;cargo new 与 cargo run 跑通 |
11.1 阶段 0 工具链与开发环境 |
| 命令行与 Git | 会 cd、会 git init、会看 git status |
11.1 阶段 0 工具链与开发环境 |
| 一门系统级语言 | 写过 C/C++/Java/Go/Python 任一,理解「变量、函数、返回值、指针/引用」 | 01 计算机基础与通用工程 |
| 编译与运行 | 知道 debug 与 release 的差别 | 11.1 阶段 0 工具链与开发环境 |
| 基本数据结构 | 知道数组、链表、哈希表的基本形态 | 02 数据结构与算法 |
经验判断:如果你写过 C,最容易犯的错是「把 Rust 当 C 写」——到处想要指针、想手动管理内存、用 unsafe 绕开检查。写过 Java 的人容易把 Option 当 Optional 用,不知道它可以直接 match 而不是 .get()。写过 Go 的人容易把 Result 当 error 返回来 return,不理解 ? 的威力。这三类偏差都要在练习里主动纠正。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 变量与可变性 | let / let mut / shadowing / 常量 |
能讲清原理 | 04.4.1 所有权与类型系统 |
| 标量与复合类型 | i8–i128、f32/f64、bool、char、元组、数组 |
会用 | 04.4.1 所有权与类型系统 |
| 控制流 | if/else、loop/while/for、break/continue |
会用 | 04.4.1 所有权与类型系统 |
| 枚举与匹配 | enum、match、if let、while let、穷尽性 |
能讲清原理 | 04.4.1 所有权与类型系统 |
Option 与 Result |
Some/None、Ok/Err、? 初步 |
能讲清原理 | 04.4.1 所有权与类型系统 |
结构体与 impl |
具名结构体、元组结构体、单元结构体、关联函数 | 会用 | 04.4.1 所有权与类型系统 |
| 模块与可见性 | mod、use、pub/pub(crate)/pub(in path) |
会用 | 04.4.1 所有权与类型系统 |
String 与切片 |
String/&str/&[T]/&mut [T]、UTF-8 |
能讲清原理 | 04.4.1 所有权与类型系统 |
| 集合选取 | Vec、HashMap、BTreeMap、复杂度 |
会用 | 02 数据结构与算法 |
| 格式化与溢出 | Debug/Display、{:?}、overflow-checks |
会用 | 04.4.1 所有权与类型系统 |
进度管理建议:把这张表复制到自己的笔记里,每学完一个模块把「掌握程度」往下调一档;三档都到位再进阶段 2。《知识点全清单》是本篇更细的全量清单。
五、分模块精讲
5.1 变量、可变性与 shadowing
为什么需要它:Rust 的默认不可变与大多数语言相反。这一选择不是「语法洁癖」,而是为了让借用检查器能在编译期知道「谁会改这个值」。不先接受这个规则,后面所有借用规则都会觉得「莫名其妙」。
核心机制:
let x = 5;出来的x是不可变的;x = 6;会报cannot assign twice to immutable variable。let mut x = 5;出来的x可变,但变量的类型不能变(x = "hello"仍报错)。- shadowing(影子绑定):
let x = x + 1;会新建一个新的变量绑定,旧的x被遮蔽;它与mut的区别是 shadowing 可以改变类型。例如let s = " 42 "; let s = s.trim();把&str重新绑定为&str,但let s = s.trim().len();会变成usize。 const必须显式标注类型,且只能是编译期常量;static是全局可变或不可变的生命周期为'static的值,访问static mut是unsafe。- 函数参数默认不可变;要在函数体内改参数需要
let mut p = p;重新绑定。
最小可运行示例:
fn main() {
let x = 5;
// x = 6; // 编译错误:cannot assign twice to immutable variable
let x = x + 1; // shadowing:新绑定
{
let x = x * 2; // 内层 shadowing
println!("inner x = {x}"); // 12
}
println!("outer x = {x}"); // 6
let mut s = String::from("hello");
s.push_str(", world"); // mut 允许改内容,但类型仍是 String
println!("{s}");
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0384]: cannot assign twice to immutable variable |
用了 let 想赋值 |
改 let mut x = ... |
error[E0308]: mismatched types |
shadowing 后想赋不同类型给 mut 变量 |
用 let 重新绑定,而不是改 mut 变量 |
| 函数里改了参数,调用方看不到 | 参数默认不可变,函数内重新绑定 | 函数参数前加 mut,或返回新值 |
static mut 读写报 unsafe |
全局可变静态是未定义行为温床 | 用 OnceLock/LazyLock 或 Mutex(阶段 4) |
面试考法:常问「let mut x 与 let x = ...; let x = ...; 有什么区别」。答到「mut 允许修改同一绑定的内容,类型不变;shadowing 是新建一个绑定,可以改类型,旧绑定在作用域内仍存在但被遮蔽」。追问会问「为什么 Rust 默认不可变」,答案是「让借用检查器在编译期知道哪些引用指向的值可能被改,从而避免数据竞争」。
5.2 标量与复合类型
为什么需要它:Rust 的整型宽度是显式的,int 与 i32、i64 完全分开;char 是 4 字节 Unicode 标量而不是 ASCII 字节。这些显式选择让 Rust 在嵌入式与跨平台场景下行为可预测,但也意味着 C/Java 里「int 就是 int」的直觉要重学。
核心机制:
- 有符号整型:
i8/i16/i32/i64/i128/isize;无符号:u8/u16/u32/u64/u128/usize。isize/usize宽度等于指针宽度(64 位平台上 8 字节)。 - 浮点:
f32/f64,默认f64。 bool是 1 字节;char是 4 字节 Unicode 标量(不是字节),所以'中'是合法的char。- 元组
(i32, String, bool)可以解构:let (a, b, c) = t;。 - 数组
[i32; 4]长度是类型的一部分,定长;Vec<i32>才是动态长度。 - 类型转换必须显式:
let x = 5u32; let y = x as i64;,没有隐式提升。
最小可运行示例:
fn main() {
let a: i32 = -42;
let b: u32 = a as u32; // 显式转换,负数变巨大无符号数
println!("{a} -> {b}");
let c: char = '中';
println!("{} 占 {} 字节", c, std::mem::size_of::<char>()); // 4 字节
let t = (1, "hello", true);
let (n, s, flag) = t; // 元组解构
println!("{n}, {s}, {flag}");
let arr: [i32; 3] = [1, 2, 3]; // 数组长度固定为 3
println!("数组长度 {},第一个元素 {}", arr.len(), arr[0]);
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0308]: mismatched types expected i32, found u32`` |
整型不能隐式转换 | 显式 as,或用 try_into(阶段 3) |
char 变量存了单个字节但打印出来是两个 |
把 u8 当 char 用 |
b'x' 是 u8,'x' 是 char |
| 数组长度变化时编译失败 | 数组长度是类型一部分 | 用 Vec<T> |
usize 与 i32 在循环里比较报错 |
宽度不同 | 显式转换 i as usize |
面试考法:常问「isize/usize 是干什么的,为什么不直接用 i32」。答到「它们是指针宽度,用于索引与指针运算,64 位平台上 8 字节;这样数组索引在 32 位与 64 位平台上都不会溢出」。追问会问「char 为什么是 4 字节,与 Go 的 rune 有什么关系」,答案是「两者都是 Unicode 标量值(code point),不是字节;Go 的 rune 是 int32 别名,Rust 的 char 是独立类型但宽度相同」。
5.3 控制流与穷尽性匹配
为什么需要它:Rust 的 match 不是 C 的 switch,它是一个表达式,必须穷尽。这意味着「你忘了处理某种情况」在 Rust 里是编译错误,而不是运行时 bug。
核心机制:
if/else if/else条件必须是bool,不会把整数当真假;if x { }而x: i32会编译错误。if是表达式:let y = if x > 0 { 1 } else { -1 };,两个分支必须返回同类型。loop是无限循环,可用break value返回值;while cond条件式循环;for x in iter是唯一的遍历写法,for i in 0..10用 range。match穷尽性:必须覆盖所有可能;未覆盖时编译错误error[E0004]: non-exhaustive patterns。match臂用=>分隔,多个条件用|连接,范围用..=:1..=5。if let处理只关心一个分支的情况;while let在循环里解包 Option/Result。
最小可运行示例:
fn classify(n: i32) -> &'static str {
match n {
0 => "zero",
1 | 2 => "one or two",
3..=9 => "small positive",
_ if n < 0 => "negative",
_ => "large",
}
}
fn main() {
let x = 5;
let category = match x {
0 => "zero",
1..=10 => "small",
_ => "other",
};
println!("{category}");
// if let:只关心 Some 分支
let maybe = Some(42);
if let Some(v) = maybe {
println!("got {v}");
}
// while let:迭代到 None 为止
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("pop {top}");
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0004]: non-exhaustive patterns: None not covered |
match 没处理 None | 补 None => ... 或用 _ => ... |
error[E0308]: mismatched types expected bool, found integer |
把 if n 当 C 用 |
if n != 0 |
match 臂返回类型不一致 |
某臂返回 () 某臂返回 i32 |
所有臂返回同类型 |
if let 漏处理 None 导致逻辑错 |
只关心成功分支 | 需要兜底时改 match |
面试考法:常问「Rust 的 match 与 C 的 switch 有什么区别」。答到「穷尽性、表达式、模式匹配(解构结构体与枚举变体)、没有 fallthrough、_ 是兜底而非 default」。追问会问「穷尽性检查在大型重构中帮了什么忙」,答案是「枚举加一个变体后,编译器会把所有没处理新变体的 match 标红,这是编译器驱动重构的核心机制」。
5.4 枚举与 Option/Result
为什么需要它:Rust 没有 null,但业务里处处是「可能没有」「可能失败」。Option<T> 与 Result<T, E> 是这两个概念的类型化表达。不掌握它们,就无法写任何有 IO 的代码。
核心机制:
enum Option<T> { Some(T), None }:表达「可能有值」。enum Result<T, E> { Ok(T), Err(E) }:表达「可能成功」。Option<T>与Result<T, E>是普通枚举,可以match、可以if let、可以?。?运算符:在返回Result的函数里,let x = f()?;会在Err时提前 return,把Err通过From转换为当前函数的错误类型(阶段 3 展开)。Option常用方法:unwrap_or、unwrap_or_else、map、and_then、ok_or、ok_or_else。Result常用方法:unwrap_or、map_err、and_then、?。Option::unwrap()与Result::unwrap()在None/Err时 panic,只在示例代码或测试里用,生产代码要给出兜底。
最小可运行示例:
use std::fs::File;
use std::io::Read;
fn find_user(id: u32) -> Option<&'static str> {
match id {
1 => Some("ann"),
2 => Some("bob"),
_ => None,
}
}
fn read_config(path: &str) -> Result<String, std::io::Error> {
let mut f = File::open(path)?; // 失败时提前 return Err
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
}
fn main() -> Result<(), std::io::Error> {
let user = find_user(1).unwrap_or("guest");
println!("user = {user}");
let cfg = read_config("not-exist.txt").unwrap_or_else(|_| String::from("{}"));
println!("cfg = {cfg}");
// map 与 and_then:把 Option<T> 转换成 Option<U>
let len = find_user(1).map(|u| u.len()).unwrap_or(0);
println!("len = {len}");
Ok(())
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0308]: mismatched types expected enum Option<_>`` |
函数返回 Option 但某分支返回 T |
包 Some(...) |
error[E0277]: ?couldn't convert the error toE`` |
? 的错误类型与函数返回类型不匹配 |
用 map_err 转换,或让错误类型实现 From |
生产代码里到处 unwrap() 后 panic |
习惯把 unwrap 当 Java 的 .get() |
用 unwrap_or、?、ok_or 兜底 |
Option<&str> 与 Option<String> 混用 |
所有权边界(阶段 2 展开) | 函数签名统一用 Option<&str> 接收 |
面试考法:高频题是「Rust 怎么解决 NullPointerException」。答到「没有 null 类型,所有可能缺失的场景必须用 Option<T> 表达;编译器强制你 match 出 None 分支,不存在『忘了判空』的运行时错误」。追问会问「? 与 Java 的 try-catch 有什么区别」,答案是「? 是类型化的提前返回,错误通过 From 自动转换;try-catch 是运行时异常跳转,类型上不强制处理」。再追问会问「Option::unwrap 为什么是危险的」,答案是「它在 None 时 panic,是把编译期检查绕成运行时崩溃;生产代码应当给兜底」。
5.5 结构体、impl 与关联函数
为什么需要它:结构体是 Rust 组织数据的主要方式,impl 块是给结构体挂方法的方式。Rust 没有「类」,数据与方法的关联靠 impl,这与 Go 的接收者函数很像,但 Rust 把 Self 与 Self:: 的写法规范化了。
核心机制:
- 三种结构体形态:
- 具名结构体
struct User { name: String, age: u32 }; - 元组结构体
struct Point(i32, i32),字段无名字,访问用.0、.1; - 单元结构体
struct Marker;,没有字段,用于 trait 类型或占位。
- 具名结构体
impl块:impl User { fn new(name: String) -> Self { ... } }。- 关联函数(associated function):第一个参数不是
self的函数,调用用User::new(...),相当于其他语言的静态方法。 - 方法:第一个参数是
&self、&mut self或self,调用用u.age()。 Self是当前类型的别名;Self::new(...)在impl内部调用关联函数。- 结构体更新语法
let u2 = User { age: 30, ..u1 };会把u1的其余字段搬过来(注意String字段会 move,阶段 2 展开)。 - 元组结构体可以作为「类型包装」,例如
Meters(f64)与Feet(f64)是不同类型,不会误用。
最小可运行示例:
#[derive(Debug)]
struct User {
name: String,
age: u32,
}
impl User {
// 关联函数(构造器)
fn new(name: String, age: u32) -> Self {
Self { name, age }
}
// 只读方法
fn greet(&self) -> String {
format!("hi, I'm {} ({})", self.name, self.age)
}
// 可变方法
fn birthday(&mut self) {
self.age += 1;
}
}
// 元组结构体:用于类型包装
struct Meters(f64);
struct Feet(f64);
impl Meters {
fn to_feet(&self) -> Feet {
Feet(self.0 * 3.28084)
}
}
fn main() {
let mut u = User::new(String::from("ann"), 28);
println!("{}", u.greet());
u.birthday();
println!("{u:?}");
let m = Meters(10.0);
let f = m.to_feet();
println!("10m = {:.2}ft", f.0);
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0599]: no function or associated item named new found |
写错调用语法 | 关联函数用 User::new(...),方法用 u.new(...) |
| 方法里改了字段,外面看还是旧值 | 方法签名是 &self 不是 &mut self |
改 fn birthday(&mut self) |
struct update 后原变量不能用了 |
String 字段被 move(阶段 2) |
用 #[derive(Clone)] 或复制实现 Copy 的字段 |
| 元组结构体访问用了字段名 | 元组结构体没有名字 | 用 .0、.1 |
面试考法:常问「Rust 为什么没有类」。答到「数据(struct)与行为(impl)分离,但可以放在同一个文件;继承用 trait(阶段 3)替代;组合优于继承」。追问会问「&self、&mut self、self 三种接收者怎么选」,答案是「只读用 &self;需要改字段用 &mut self;需要消费对象(如 into_iter)用 self」。
5.6 模块与可见性
为什么需要它:Rust 的模块系统是层级化的,与文件系统的关系是「约定大于配置」。mod 声明在哪个文件、pub 写到什么粒度,决定了外部代码能看到什么。不掌握这一节,就会出现「明明写了 fn,为什么 use 不进来」的诡异错误。
核心机制:
mod xxx;声明一个子模块,对应xxx.rs或xxx/mod.rs。- 默认所有项都是私有的;父模块看不到子模块的私有项,子模块能看到父模块的私有项。
pub让项对外可见;pub(crate)只在当前 crate 内可见;pub(in crate::a::b)只在指定路径内可见;pub(super)只在父模块内可见。use是引入路径到当前作用域;use crate::a::b::C;之后可以直接写C。pub use是重新导出:把别人内部的东西对外暴露成自己的 API,常用于重写模块层级。crate::表示从 crate 根开始;super::表示父模块;self::表示当前模块。
最小可运行示例:
src/
├── main.rs
└── auth/
├── mod.rs
└── password.rs
// src/auth/mod.rs
pub mod password; // 子模块对外可见
pub(crate) fn internal() {} // 只在 crate 内可见
// src/auth/password.rs
pub fn hash(p: &str) -> String {
format!("hashed:{p}")
}
fn helper() -> bool { true } // 私有
// src/main.rs
mod auth; // 声明 auth 模块
fn main() {
let h = auth::password::hash("secret");
println!("{h}");
// auth::password::helper(); // 编译错误:helper 私有
// auth::internal(); // 只在 crate 内可见,main 在 crate 内所以 OK
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0432]: unresolved import |
路径写错或没 pub |
检查模块层级与 pub 标注 |
error[E0603]: function helper is private |
函数没 pub |
在 fn 前加 pub,或用 pub(crate) 限制 |
mod xxx; 编译时找不到文件 |
文件名不匹配 | mod auth; 对应 auth.rs 或 auth/mod.rs |
| 对外 API 暴露了内部层级 | 没做 pub use 重导出 |
在 lib.rs 用 pub use auth::password; 重写 API 表面 |
面试考法:常问「Rust 的可见性与 Java 的 public/private/protected 有什么不同」。答到「Rust 默认私有,且可见性是层级化的(父可见子私有、子可见父私有);pub(crate)、pub(in path) 提供细粒度控制;Java 的 protected 还受包访问规则约束」。追问会问「pub use 有什么用」,答案是「重导出,让你在内部用多层模块组织代码,但对外暴露成扁平的 API,避免外部代码依赖你的内部层级」。
5.7 String、&str 与切片
为什么需要它:这是 Rust 新手最容易卡住的点之一。C/C++ 里「字符串就是 char 指针」,Java 里「String 是不可变对象」,Go 里「string 是只读字节切片」。Rust 把 String(拥有所有权、可变、堆分配)与 &str(借用的字符串切片、UTF-8 字节视图)完全分开。函数签名选 String 还是 &str,直接决定 API 好不好用。
核心机制:
String:堆分配、可变、拥有所有权,Vec<u8>的语义封装;String::from("hello")创建。&str:&[u8]的 UTF-8 安全视图,是借用,不拥有数据;字符串字面量"hello"的类型是&'static str。String与&str互转:&s把&String强转成&str(Deref 强制);s.to_string()或&s[..].to_string()把&str复制成String。- 字符串切片
&s[0..3]必须落在字符边界上,否则 panic(byte index N is not a char boundary)。 - 通用切片
&[T]与&mut [T]:Vec<T>的借用视图;&v[..]与&mut v[..]。 - 选择 API 签名:函数只读字符串时用
&str,不要用&String(不必要地约束调用方);函数需要拥有或拼接字符串时用String。
最小可运行示例:
fn greet(name: &str) -> String {
format!("hello, {name}")
}
fn main() {
let owned = String::from("ann");
let lit = "bob";
println!("{}", greet(&owned)); // &String 自动 Deref 成 &str
println!("{}", greet(lit)); // &'static str 直接传
let s = String::from("你好 rust");
// 切片必须在字符边界
println!("{}", &s[0..6]); // 你好(3 字节 × 2 = 6 字节)
// println!("{}", &s[0..3]); // panic: byte index 3 is not a char boundary
// 数字切片
let v = vec![1, 2, 3, 4];
let head: &[i32] = &v[..2];
println!("{:?}", head); // [1, 2]
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
error[E0277]: the trait bound &String: Into<&str>`` 这类报错 |
函数签名写了 &String 但传了 &str |
把签名改成 &str |
panic: byte index N is not a char boundary |
切片切在多字节字符中间 | 用 chars() 迭代,或用 char_indices() 找边界 |
String 与 &str 反复 .to_string() 导致性能问题 |
每次都复制 | 函数参数用 &str,返回按需 String |
&mut [T] 改了切片外面 Vec 也变了 |
切片是借用视图 | 这是预期行为;要独立数据用 to_vec() |
面试考法:高频题是「String 与 &str 的区别,API 应该选哪个」。答到「String 是拥有所有权的可变堆字符串;&str 是借用的 UTF-8 切片视图;只读参数用 &str,拥有或拼接用 String」。追问会问「为什么 Rust 不把 &String 当 &str 等价,而要靠 Deref」,答案是「&String 引入了不必要的约束——调用方必须先有 String 才能调用,而 &str 让字面量、Box<str>、Arc<str> 都能直接传」。
5.8 集合选取与整数溢出
为什么需要它:Vec、HashMap、BTreeMap 是 Rust 最常用的三个集合,但选哪个不只是「个人喜好」,而是复杂度与内存布局的权衡。整数溢出在 debug 与 release 下行为不同,这是生产事故的常见来源。
核心机制:
Vec<T>:动态数组,末尾push/pop均摊 O(1),随机访问 O(1);扩容时整体复制。HashMap<K, V>:哈希表,查找/插入均摊 O(1);无序;键必须Hash + Eq。BTreeMap<K, V>:B 树,查找/插入 O(log n);按键排序;适合「按范围遍历」「求最小/最大键」场景。HashSet<T>与BTreeSet<T>是集合语义的封装。- 整数溢出:debug profile 默认
overflow-checks = true,溢出时 panic;release profile 默认false,溢出时静默回绕(two's complement)。 - 显式选择语义:
x.wrapping_add(y)总是回绕;x.checked_add(y)返回Option;x.saturating_add(y)饱和到最大值;x.overflowing_add(y)返回(result, did_overflow)。
最小可运行示例:
use std::collections::{BTreeMap, HashMap};
fn main() {
// HashMap:按 ID 查
let mut users = HashMap::new();
users.insert(1, "ann");
users.insert(2, "bob");
println!("{:?}", users.get(&1)); // 顺序不确定
// BTreeMap:按键排序遍历
let mut scores = BTreeMap::new();
scores.insert(3, "high");
scores.insert(1, "low");
scores.insert(2, "mid");
for (k, v) in &scores {
println!("{k}: {v}"); // 1, 2, 3 顺序
}
// 显式溢出语义
let max = i32::MAX;
println!("wrapping: {}", max.wrapping_add(1)); // -2147483648
println!("checked: {:?}", max.checked_add(1)); // None
println!("saturating: {}", max.saturating_add(1)); // 2147483647
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
debug 下 thread 'main' panicked at 'attempt to add with overflow' |
整数溢出触发了 debug 检查 | 用 checked_add 或业务上确认是否允许回绕 |
| release 下计算结果突然变负数 | 静默回绕 | 关键路径加 checked_add 或在 release 也开 overflow-checks 调试 |
HashMap 遍历顺序与插入顺序不一致 |
哈希表无序 | 要顺序用 BTreeMap,或单独维护 key 列表 |
频繁 push 导致 Vec 反复扩容 |
没预分配 | Vec::with_capacity(n) |
面试考法:常问「HashMap 与 BTreeMap 怎么选」。答到「查找/插入为主用 HashMap(O(1));需要按键排序遍历、范围查询、最小/最大键用 BTreeMap(O(log n))」。追问会问「为什么 release 下整数溢出静默回绕,这不是 bug 吗」,答案是「这是性能选择——release 追求吞吐,把溢出检查去掉;生产代码关键路径应当显式选 checked_*/saturating_*,而不是依赖 profile 默认」。
六、分层练习
6.1 复现型(照着做,目标是「跑通 + 能解释」)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 变量与 shadowing | 写一段演示 let mut 与 let 重新绑定的代码 |
能说清两者差异;cargo clippy 无 warning |
0.5 小时 |
| 穷尽性 match | 写一个 enum Color { Red, Green, Blue, Custom(u8, u8, u8) },写一个 match 覆盖所有变体 |
故意删掉 Custom 分支,看 non-exhaustive patterns 报错 |
1 小时 |
| Option/Result 改写 | 把一段 Java 风格的「返回 null / 返回错误码」改写成 Option/Result |
函数签名没有 null 或错误码;调用方用 ? 或 unwrap_or |
1.5 小时 |
| String 与 &str | 写一个 fn greet(name: &str) -> String,分别用 String::from 与字面量调用 |
解释为什么 &String 能自动当 &str |
1 小时 |
| 容器对比 | 用 HashMap 与 BTreeMap 各存一份同一组数据,遍历对比顺序 |
能说清两者适用场景 | 1 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
把 unwrap 改成兜底 |
给定一段满屏 unwrap() 的代码,改成 unwrap_or/?/ok_or |
cargo clippy 不再报 unwrap_used(如启用);单元测试覆盖失败分支 |
1.5 小时 |
| 函数签名收紧 | 给定 fn f(s: &String) 改成 fn f(s: &str) |
所有调用方无需改动;调用方可以直接传字面量 | 0.5 小时 |
| 切片 panic 修复 | 给定一段对中文 &s[0..3] 切片的代码,改成 chars() 安全遍历 |
不再 panic;输出符合预期 | 1 小时 |
| 溢出语义选择 | 给定 i32::MAX + 1 的业务累加,改成 saturating_add 并写测试 |
release 下不再静默回绕;测试覆盖溢出分支 | 1 小时 |
| 模块层级重构 | 给定一个所有函数都堆在 main.rs 的工程,拆成 auth/、store/ 模块并用 pub use 重导出 |
外部调用方代码不变;内部文件分层清晰 | 2 小时 |
6.3 设计型(自己定方案,目标是「能交付、能讲清取舍」)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 命令行待办工具 | 实现一个 CLI:增删查、按状态过滤、持久化到 JSON | 用 enum Status { Pending, Done }、Vec<Todo>、HashMap 索引;? 处理文件 IO |
4 小时 |
| 类型安全的距离单位 | 定义 Meters、Feet、Kilometers 元组结构体,提供转换函数 |
编译期不能把 Meters 直接当 Feet 用 |
3 小时 |
| 日志等级枚举 | 实现 enum Level { Debug, Info, Warn, Error },按等级过滤 |
用 match 穷尽性;提供 FromStr 解析字符串等级 |
2 小时 |
| 配置解析器 | 从环境变量与文件两路合并配置,缺失字段返回结构化错误 | 错误类型用 enum ConfigError;? 串联;不吞错误 |
4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
error[E0384]: cannot assign twice to immutable variable |
用了 let 想赋值 |
看变量声明行 | 改 let mut 或 let 重新绑定 |
error[E0004]: non-exhaustive patterns |
match 漏了某个变体 | 看编译器提示「not covered」的是哪个 | 补对应分支或加 _ 兜底 |
error[E0308]: mismatched types expected Option<_>`` |
函数返回 Option 但某分支直接返回 T | 看分支返回值 | 包 Some(...) |
error[E0603]: function xxx is private |
函数没 pub |
看函数定义行 | 加 pub 或 pub(crate) |
panic: byte index N is not a char boundary |
切在多字节字符中间 | 用 char_indices() 看边界 |
用 chars() 迭代,或按字符边界切片 |
thread 'main' panicked at 'called Option::unwrap()on aNone value' |
生产代码用 unwrap 兜底失败 |
看 unwrap 调用栈 |
改 unwrap_or、ok_or 或 ? |
debug 下 attempt to add with overflow |
整数溢出触发了 debug 检查 | 看溢出位置 | 用 checked_add/saturating_add,或确认业务语义 |
error[E0432]: unresolved import |
模块路径错或没 pub |
cargo build 看具体缺失项 |
修正路径,或在模块上加 pub |
八、出口条件
全部勾选后再进入 阶段 2 所有权、借用与生命周期。
- [ ] 能写一个带
enum、match、Option、Result的 CLI,cargo clippy -- -D warnings通过 - [ ] 能解释
let mut与 shadowing 的区别,并在函数参数上正确使用mut - [ ] 能写出穷尽性
match,枚举加变体后能让编译器指出所有漏处理点 - [ ] 能用
?串联文件 IO 与业务逻辑,错误类型用enum表达 - [ ] 能在 API 签名里正确选择
&str、String、&[T]、&mut [T],并解释为什么 - [ ] 能说清
Vec/HashMap/BTreeMap的复杂度与选取依据 - [ ] 能解释 debug 与 release 的整数溢出行为差异,关键路径用
checked_add或saturating_add - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
let mut x = 5; let x = x + 1;与let mut x = 5; x = x + 1;有什么区别?- 要点:前者是 shadowing,新建了一个不可变绑定;后者是修改同一绑定。前者在第二步后
x不可变,后者仍然可变。
- 要点:前者是 shadowing,新建了一个不可变绑定;后者是修改同一绑定。前者在第二步后
match为什么必须穷尽?这种设计在大型重构中帮了什么忙?- 要点:穷尽性保证所有变体都被处理;枚举加变体后编译器会把所有没处理新变体的
match标红,是编译器驱动重构的核心。
- 要点:穷尽性保证所有变体都被处理;枚举加变体后编译器会把所有没处理新变体的
Option<T>::unwrap()为什么是危险的?生产代码应当怎么替代?- 要点:它在
None时 panic,把编译期检查绕成运行时崩溃;用unwrap_or、ok_or、?给兜底,或用expect写明预期原因。
- 要点:它在
- 函数参数为什么优先用
&str而不是&String?- 要点:
&String强制调用方先有String;&str让字面量、Box<str>、Arc<str>都能直接传,API 更通用。
- 要点:
HashMap与BTreeMap在什么场景下各自胜出?- 要点:查找/插入为主用 HashMap(O(1));需要按键排序遍历、范围查询、最小/最大键用 BTreeMap(O(log n))。
- debug 与 release 下
i32::MAX + 1行为有什么不同?生产代码怎么避免意外?- 要点:debug panic,release 静默回绕;关键路径用
checked_add/saturating_add显式选语义,不要依赖 profile 默认。
- 要点:debug panic,release 静默回绕;关键路径用
pub(crate)与pub有什么区别?什么时候用pub(crate)?- 要点:
pub对外 crate 可见;pub(crate)只在本 crate 内可见,用于内部工具函数——对外暴露会污染 API 表面,但跨模块又需要访问。
- 要点: