罗罗编程学习记录
本页内容 展开查看

11.2 阶段 1 语言基础与类型系统

所属:全栈开发面试题库 / 学习路径 / 11 Rust 全栈

本页目录

一、阶段定位

阶段 0 把工具链装好后,本阶段正式开始写 Rust 代码。但它不是「Rust 语法大全」——那部分你在 The Book 里能看完。本阶段聚焦的是 Rust 与 C/C++、Java、Go 在数据表示与控制流上的硬差异,这些差异决定了后面阶段 2 的所有权、阶段 3 的 trait 为什么必须这样设计:

  1. 不可变是默认:let x = 5; 出来的 x 不能再赋值,必须 let mut x = 5; 才能改。这与 C/Java 的「变量默认可变」完全相反。
  2. 没有 null,只有 Option<T>:任何「可能没有」的情况必须用 Option 类型表达,编译器强制你处理 None。Java 的 NPE 与 Go 的 nil 这类运行时错误在 Rust 里根本编译不过。
  3. 穷尽性匹配:match 必须覆盖所有可能,枚举加一个变体,所有 match 都要改。这是「编译器帮你改代码」的开端。
  4. 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:: 的写法规范化了。

核心机制:

  • 三种结构体形态:
    1. 具名结构体 struct User { name: String, age: u32 };
    2. 元组结构体 struct Point(i32, i32),字段无名字,访问用 .0、.1;
    3. 单元结构体 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 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. let mut x = 5; let x = x + 1; 与 let mut x = 5; x = x + 1; 有什么区别?
    • 要点:前者是 shadowing,新建了一个不可变绑定;后者是修改同一绑定。前者在第二步后 x 不可变,后者仍然可变。
  2. match 为什么必须穷尽?这种设计在大型重构中帮了什么忙?
    • 要点:穷尽性保证所有变体都被处理;枚举加变体后编译器会把所有没处理新变体的 match 标红,是编译器驱动重构的核心。
  3. Option<T>::unwrap() 为什么是危险的?生产代码应当怎么替代?
    • 要点:它在 None 时 panic,把编译期检查绕成运行时崩溃;用 unwrap_or、ok_or、? 给兜底,或用 expect 写明预期原因。
  4. 函数参数为什么优先用 &str 而不是 &String?
    • 要点:&String 强制调用方先有 String;&str 让字面量、Box<str>、Arc<str> 都能直接传,API 更通用。
  5. HashMap 与 BTreeMap 在什么场景下各自胜出?
    • 要点:查找/插入为主用 HashMap(O(1));需要按键排序遍历、范围查询、最小/最大键用 BTreeMap(O(log n))。
  6. debug 与 release 下 i32::MAX + 1 行为有什么不同?生产代码怎么避免意外?
    • 要点:debug panic,release 静默回绕;关键路径用 checked_add/saturating_add 显式选语义,不要依赖 profile 默认。
  7. pub(crate) 与 pub 有什么区别?什么时候用 pub(crate)?
    • 要点:pub 对外 crate 可见;pub(crate) 只在本 crate 内可见,用于内部工具函数——对外暴露会污染 API 表面,但跨模块又需要访问。