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

04.4.1.4 错误处理、迭代器与常用类型

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.1 所有权与类型系统

04.4.1.4-001 Result<T, E> 与 Option<T> 的设计思路?

一句话结论

Option<T> 表示“可能没有值”(None/Some),Result<T, E> 表示“可能失败”(Ok/Err);二者都是枚举,把空值与失败纳入类型系统,避免空指针与隐式异常。

概念解释

Rust 不用 null 表示缺失,也不用异常中断控制流。可选值用 Option,可恢复错误用 Result,调用方必须显式处理 None/Err 分支,编译器强制不漏掉。

原理流程

  1. 函数返回 Option<T> 或 Result<T, E>。
  2. 调用方用 match/组合子/? 处理两种分支。
  3. 未处理的 None/Err 无法静默传播到错误位置。

代码或图示

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 { None } else { Some(a / b) }
}

常见误区

  • 以为 Option 和 Result 可互相替代:Option 没有错误信息,Result 携带失败原因。
  • 以为可以直接对 None 取值:必须先匹配或用 unwrap_or 提供默认值。

追问

  • 标准库哪些函数返回 Option?答:哈希查找 get、迭代器 next、类型转换 from_str 失败分支等。
  • 如何把 Option 转 Result?答:ok_or(err)/ok_or_else,把缺失映射成指定错误。

04.4.1.4-002 可恢复错误用 Result、不可恢复用 panic,如何选择?

一句话结论

可预期、调用方应处理的失败(IO 失败、校验不通过)返回 Result;违反内部不变量、不可能继续运行的 bug 用 panic!;库代码优先返回 Result,应用层再决定是否 panic。

概念解释

Result 是正常控制流的一部分;panic 表示程序状态已不可靠,默认展开或终止线程/进程。把业务错误当 panic 会让调用方无法兜底,把致命 bug 当 Result 会掩盖问题。

原理流程

  1. 判断失败是否可预期、可恢复。
  2. 可恢复 → 定义错误类型返回 Result。
  3. 不变量被破坏 → panic 或断言;边界层再决定捕获 unwind。

代码或图示

fn read_cfg() -> Result<String, std::io::Error> {
    std::fs::read_to_string("cfg.toml")
}
// 不变量:索引必须合法,否则 panic
assert!(idx < len, "index out of bounds");

常见误区

  • 以为所有错误都该 panic 快速失败:业务可恢复错误应交给调用方决策。
  • 以为库代码到处 unwrap 没问题:unwrap 遇到 Err 直接 panic,库应返回错误。

追问

  • panic 后程序一定退出吗?答:默认展开栈,线程内 panic 可被 catch_unwind 捕获;主线程 panic 通常导致进程退出,配置 panic=abort 则直接终止。
  • 断言与 panic 区别?答:assert!/debug 检查在条件失败时 panic;panic! 是显式触发,二者都表示不可继续。

04.4.1.4-003 ? 运算符如何传播错误?

一句话结论

? 作用于 Result(或 Option):成功则取出内部值继续执行;失败则提前返回,把错误经 From 转换后返回给调用方。

概念解释

? 省去手写 match 转发错误。它要求函数返回类型能容纳该错误:错误类型实现 From 转换到返回类型的 E;Option 上的 ? 在 None 时提前返回 None。

原理流程

  1. 表达式为 Ok(v) → 绑定 v 继续。
  2. 为 Err(e) → 调用 e.into() 转成返回类型错误,提前 return。
  3. 函数返回类型必须与转换后的错误兼容。

代码或图示

fn load() -> Result<u32, std::io::Error> {
    let s = std::fs::read_to_string("n.txt")?;
    let n = s.trim().parse()?; // parse 错误经 From 转为 io::Error? 需类型兼容
    Ok(n)
}

常见误区

  • 以为 ? 可以用在任何函数里:返回类型必须是 Result/Option 或兼容错误类型。
  • 以为不同错误类型自动兼容:需要 From 实现或自定义错误枚举收纳。

追问

  • 为什么示例里 parse 错误可能不兼容?答:ParseIntError 与 io::Error 间若无 From 实现需手动映射;实际代码常用统一错误类型(thiserror/anyhow)。
  • Option 上 ? 的行为?答:遇到 None 提前返回 None,Some 取值继续;常用于链式可选取值。

04.4.1.4-004 自定义错误类型怎么设计?

一句话结论

自定义错误实现 Debug/Display/std::error::Error,通过 From 收纳底层错误;库用 thiserror 派生,应用层用 anyhow 聚合。

概念解释

错误类型应携带错误类别、上下文与底层原因。Error trait 提供 source() 链;From 让 ? 自动把依赖错误转成领域错误。

原理流程

  1. 定义枚举区分错误类别。
  2. 为变体实现 Display,必要时保留 source。
  3. 为每个底层错误类型写 From,支持 ? 转换。

代码或图示

#[derive(Debug, thiserror::Error)]
enum AppError {
    #[error("配置缺失: {0}")]
    Missing(String),
    #[error("IO 错误: {0}")]
    Io(#[from] std::io::Error),
}

常见误区

  • 只返回字符串错误:丢失类型与可匹配的错误类别,调用方无法分支处理。
  • 不保留错误来源:上层只看到包装信息,排查丢失底层原因。

追问

  • std::error::Error 要求哪些方法?答:source() 默认返回 None,Display/Debug 必需;新版还涉及 Error trait 的相关方法,以当前文档为准。
  • 错误链如何打印?答:沿 source() 逐层输出,或用 anyhow 的 {:#}/{:?} 格式化展示链路。

04.4.1.4-005 thiserror 与 anyhow 分别用于什么场景?

一句话结论

thiserror 用于库定义具体、可匹配的领域错误类型;anyhow 用于应用层聚合任意错误,保留上下文与错误链,不暴露固定错误枚举。

概念解释

库需要让调用方按错误类型分支处理,thiserror 派生结构化错误;应用程序只需要把错误带上上下文上报,anyhow 的 Error 容纳多种来源。两者可配合:库出 thiserror 类型,应用边界转 anyhow。

原理流程

  1. 库 crate:定义 enum,thiserror 派生 Display/Error/From。
  2. 应用 crate:函数返回 anyhow::Result<T>。
  3. 用 context()/with_context 补充失败上下文。

代码或图示

// 库
#[derive(thiserror::Error)]
#[error("...")]
pub enum LibError { ... }

// 应用
fn main() -> anyhow::Result<()> {
    let cfg = read().with_context(|| "读取配置失败")?;
    Ok(())
}

常见误区

  • 在库里直接用 anyhow 当返回类型:调用方拿不到具体错误类别,难以匹配处理。
  • 以为 anyhow 错误不能匹配:它主要做聚合与上下文,结构化分支应在库错误类型上做。

追问

  • 两者是标准库吗?答:都是 crates.io 第三方 crate,需在 Cargo.toml 声明依赖;标准库只提供 std::error::Error 基础。
  • 如何给 anyhow 错误加上下文?答:anyhow::Context trait 提供 context/with_context,在 Result/Option 上调用。

04.4.1.4-006 unwrap/expect 的风险是什么?

一句话结论

unwrap() 在 None/Err 时直接 panic,expect(msg) 带自定义信息;它们适合原型、测试或“此处不可能失败”的断言,生产业务路径应替换为显式处理或默认值。

概念解释

unwrap 把可选/错误值强行解包,失败即终止。代码审查应区分:测试与不变量断言可接受,线上请求路径上的 unwrap 会把可恢复错误变成进程崩溃。

原理流程

  1. 匹配到 Some/Ok → 返回内部值。
  2. None/Err → panic,expect 提供 panic 信息。
  3. 生产代码用 unwrap_or/unwrap_or_else/ok_or/? 替代。

代码或图示

let v = maybe.ok_or("值缺失")?;        // 显式错误
let n = opt.unwrap_or(0);              // 默认值
// 反例:线上路径直接 unwrap
// let x = risky().unwrap();

常见误区

  • 以为 unwrap 只是“省事”:它把错误处理责任完全放弃,失败即 panic。
  • 以为 expect 比 unwrap 安全:expect 只改 panic 信息,失败行为相同。

追问

  • 测试里为什么常用 unwrap?答:测试失败应快速暴露,panic 即测试失败,语义合理。
  • 如何静态检查 unwrap 使用?答:clippy 有 unwrap_used 等 lint 可配置告警;在 CI 中开启审查。

04.4.1.4-007 Option 常用组合子有哪些?

一句话结论

map 转换内部值、and_then 链式返回 Option、unwrap_or/unwrap_or_else 提供默认值、ok_or 转 Result、filter 按条件保留。

概念解释

组合子在不手动 match 的情况下串联可选值处理:None 沿链传播,Some 被转换或继续传递。and_then 用于返回 Option 的下一步,避免嵌套 Option。

原理流程

  1. Some(v) → map/and_then 应用函数。
  2. None → 组合子直接透传 None。
  3. 需要兜底时 unwrap_or 给默认值。

代码或图示

let r = Some("12")
    .and_then(|s| s.parse::<i32>().ok())
    .map(|n| n * 2)
    .unwrap_or(0);

常见误区

  • 混淆 map 与 and_then:map 返回普通值被包回 Option;and_then 函数本身返回 Option,用于扁平化链式。
  • 以为 unwrap_or 会惰性求值:它参数立即求值;需要惰性默认值用 unwrap_or_else。

追问

  • Option::as_ref/as_mut 解决什么?答:避免消费 Option,在不取出所有权的前提下借用内部值。
  • 如何判断 Option 是否有值?答:is_some()/is_none(),或直接 match/组合子处理。

04.4.1.4-008 Result 常用组合子有哪些?

一句话结论

map 转换 Ok 值、map_err 转换 Err、and_then 链式返回 Result、unwrap_or_else 失败兜底、ok() 转 Option、transpose 交换嵌套结构。

概念解释

Result 组合子让成功路径与失败路径分别处理:Ok 沿链转换,Err 透传或被 map_err 改造。and_then 串联可能失败的下一步,避免深层嵌套 match。

原理流程

  1. Ok(v) → map/and_then 继续。
  2. Err(e) → 透传,map_err 可改造错误类型。
  3. 兜底分支用 unwrap_or_else 提供恢复值。

代码或图示

let n = read_num()
    .and_then(|s| s.parse::<i32>())
    .map_err(|e| AppError::Parse(e))
    .unwrap_or_else(|_| 0);

常见误区

  • 以为 map_err 会改变 Ok 分支:它只处理 Err,Ok 原样透传。
  • 混淆 and_then 与 map:前者函数返回 Result,后者返回普通值。

追问

  • Result::transpose 用途?答:把 Result<Option<T>, E> 转成 Option<Result<T>, E>,便于和 Option 链配合。
  • 如何只在失败时打日志?答:inspect_err(以当前版本为准)或在 and_then 失败分支显式记录。

04.4.1.4-009 Rust 迭代器是什么,为什么惰性?

一句话结论

迭代器是实现 Iterator trait 的类型,按 next() 逐个产出元素;迭代器适配器是惰性的,不消费就不计算,只有 collect/for/next 触发才真正执行。

概念解释

迭代器把遍历逻辑抽象成“取下一个”的协议。惰性求值让链式适配器只记录操作,遍历时才逐步计算,避免中间集合分配。

原理流程

  1. 从集合/生成器得到迭代器。
  2. 链式调用 map/filter 等适配器,返回新迭代器。
  3. 消费端(for、collect、count、next)驱动 next() 逐步产出。

代码或图示

let sum: i32 = (1..=5).filter(|x| x % 2 == 0).map(|x| x * x).sum();

常见误区

  • 以为写了 map 就立即遍历:适配器惰性,没有消费端不执行。
  • 以为迭代器会复制原集合:多数迭代器借视图遍历,不复制元素。

追问

  • Iterator 核心方法是什么?答:next(&mut self) -> Option<Self::Item>,其余方法都基于它提供默认实现。
  • 迭代器耗尽后再调用 next 会怎样?答:返回 None,迭代器进入耗尽状态。

04.4.1.4-010 常用迭代器适配器有哪些?

一句话结论

map 变换、filter 过滤、take/skip 截取、chain 拼接、zip 配对、enumerate 带下标、flat_map 扁平化、collect 收集成集合。

概念解释

适配器返回新迭代器,保持惰性。不同适配器对应常见遍历变换;收集端决定最终落到 Vec、HashMap、String 等容器。

原理流程

  1. 原始迭代器进入适配器链。
  2. 每个适配器在 next 时按需计算。
  3. collect 按目标类型收集全部元素。

代码或图示

let v: Vec<i32> = (0..3).chain(3..6).collect();
let pairs: Vec<_> = ["a", "b"].iter().enumerate().collect();

常见误区

  • 以为 collect 不需要类型标注:目标类型常需显式标注 turbofish 或变量类型推断。
  • 以为 flat_map 和 map 一样:flat_map 闭包返回迭代器并扁平化一层。

追问

  • 如何把迭代器收集成 HashMap?答:collect::<HashMap<_, _>>(),元素需为键值对元组。
  • 无限迭代器怎么截断?答:用 take(n) 限制产出数量,否则 collect 会一直运行。

04.4.1.4-011 IntoIterator 的三种集合迭代方式?

一句话结论

Vec<T> 可被 into_iter() 消费产生 owned 元素,iter() 产生 &T 借用,iter_mut() 产生 &mut T;for 循环对集合自动选择合适的 IntoIterator 实现。

概念解释

标准库为集合提供三种迭代:按值移动、不可变借用、可变借用。into_iter 消耗集合,iter/iter_mut 保留所有权。理解三者避免误移动或借用冲突。

原理流程

  1. for x in &v → 迭代 &T。
  2. for x in &mut v → 迭代 &mut T。
  3. for x in v → into_iter() 移动出 owned 值。

代码或图示

let v = vec![1, 2, 3];
for x in &v { println!("{}", x); }      // &i32
for x in v.iter() { ... }                // &i32
// for x in v { ... }                    // 移动,v 之后不可用

常见误区

  • 以为三种迭代产出相同类型:分别是 &T、&mut T、T,可修改性与所有权不同。
  • 以为 into_iter 只是别名:它消费集合,元素所有权转移给迭代消费方。

追问

  • 自定义集合如何支持三种迭代?答:分别实现返回引用迭代器、可变引用迭代器与 owned 迭代器的类型,并提供 iter/iter_mut/into_iter。
  • iter() 底层调用什么?答:通常基于集合切片或内部结构包装实现 Iterator 的类型。

04.4.1.4-012 String、&str、Cow<'a, str> 的区别?

一句话结论

String 是堆上可增长的 owned 字符串;&str 是指向 UTF-8 字节序列的借用切片;Cow<'a, str> 可借用可按需克隆,修改时才转 owned。

概念解释

函数参数优先 &str 以接受 String 与字面量;需要持有/拼接用 String。三者通过 Deref/转换互相衔接,字符串内容始终是合法 UTF-8。

原理流程

  1. 字面量与字符串切片是 &'static str/&str。
  2. 拼接、修改产生 String。
  3. 可能借用也可能自有时返回 Cow<str>。

代码或图示

fn greet(name: &str) -> String { format!("hi, {}", name) }
let owned: String = "abc".to_owned();
let view: &str = &owned;

常见误区

  • 以为 String 内部是 Vec<u8> 包装:概念上类似可增长字节缓冲,保证 UTF-8 合法。
  • 以为可以按索引取字符:s[i] 按字节索引在字符串上不可直接用,字符遍历用 chars()。

追问

  • 字符与字节遍历分别用什么?答:chars() 迭代 Unicode 字符,bytes() 迭代原始字节;len() 是字节长度。
  • 字符串拼接性能注意什么?答:循环内反复 +/format! 会重复分配,预容量或用 String 的 push_str 批量追加。

04.4.1.4-013 切片与索引访问有哪些越界与 UTF-8 陷阱?

一句话结论

切片 &[T] 按长度与容量访问,越界索引会 panic;字符串是 UTF-8 字节序列,按字节切分可能切断多字节字符导致非法 UTF-8,字符边界需用 chars()/get 检查。

概念解释

数组/向量切片越界在 debug 与 release 都做边界检查并 panic;字符串不能按字符下标直接索引,强行按字节切割可能产生非法 UTF-8 切片。

原理流程

  1. 索引/切片时检查范围是否在 len 内。
  2. 越界 → panic(Index out of bounds)。
  3. 字符串切片需确认边界落在字符边界,否则返回错误或 panic。

代码或图示

let v = vec![1, 2, 3];
let _ = &v[0..2];
// let _ = &v[..10];      // panic
let s = "中国人";
for c in s.chars() { println!("{}", c); }

常见误区

  • 以为字符串下标 s[i] 取第 i 个字符:Rust 不提供字符索引,避免歧义与 O(n) 预期。
  • 以为按字节切多字节字符仍合法:可能切断 UTF-8 序列,切片构造时会 panic。

追问

  • 安全的边界检查访问用什么?答:get(index)/get(range) 返回 Option<&T>,避免 panic。
  • 如何取第 n 个字符?答:chars().nth(n),注意是 O(n) 且按 Unicode 字符计数。

04.4.1.4-014 整数溢出在 debug 与 release 下行为有何不同?

一句话结论

debug 构建下整数溢出触发 panic(溢出检查);release 构建默认按补码环绕(wrapping),不 panic。关键数值必须显式处理溢出,不能依赖 release 行为。

概念解释

整数类型有固定位宽,超过表示范围即溢出。debug 打开 overflow checks 便于暴露 bug;release 关闭检查以追求性能,环绕行为可能产生错误数值。

原理流程

  1. 运算结果超过类型范围。
  2. debug:溢出检查命中 → panic。
  3. release:默认环绕;可用 checked_*/saturating_*/wrapping_* 显式选择语义。

代码或图示

let a: u8 = 255;
let b = a.checked_add(1);        // None
let c = a.saturating_add(1);      // 255
let d = a.wrapping_add(1);       // 0

常见误区

  • 以为 release 下溢出也会报错:默认环绕,需主动用 checked 系列。
  • 以为无符号环绕没有风险:计数器、长度计算环绕会导致越界/逻辑错误。

追问

  • 哪些方法显式控制溢出?答:checked_add 返回 Option、saturating_* 饱和、wrapping_* 环绕、overflowing_* 返回值加标志。
  • 溢出检查可以全局配置吗?答:可在 profile/编译参数调整 overflow checks;具体开关以当前工具链文档为准。

04.4.1.4-015 元组、单元类型 () 与枚举模式匹配怎么用?

一句话结论

元组组合多个不同类型的值;() 是单元类型表示无返回值;枚举用 match 穷尽匹配每个变体,结合解构提取内部数据。

概念解释

元组是轻量多值结构;单元类型类似其他语言的 void。枚举变体可携带数据,match 必须覆盖所有变体,编译器帮助检查遗漏。

原理流程

  1. 函数可返回元组多值。
  2. 无返回类型标注为 ()。
  3. 枚举经 match 解构,分支绑定变体内部字段。

代码或图示

fn pair() -> (i32, &'static str) { (1, "ok") }
let (n, label) = pair();

enum Shape { Circle(f64), Rect(f64, f64) }
match shape {
    Shape::Circle(r) => println!("r={}", r),
    Shape::Rect(w, h) => println!("{}x{}", w, h),
}

常见误区

  • 以为 match 可以漏掉分支:非穷尽匹配编译错误,可用 _ 兜底。
  • 以为元组必须命名字段:元组按位置取值,需要命名字段用结构体。

追问

  • match 与 if let 区别?答:match 穷尽并可多分支;if let 只关心单个变体,其余忽略。
  • 枚举能携带方法吗?答:可以,枚举也可 impl 块定义方法,按变体在方法内分支。

04.4.1.4-016 HashMap/BTreeMap 如何选择,键有什么约束?

一句话结论

HashMap 基于哈希,平均 O(1) 查找,键要求 Eq + Hash;BTreeMap 基于有序 B 树,按键有序遍历,键要求 Ord;不需要顺序时优先 HashMap。

概念解释

HashMap 不保证遍历顺序,适合查找/插入为主;BTreeMap 维护排序,需要范围查询、有序迭代时使用。键类型必须满足对应 trait 约束。

原理流程

  1. 按是否需要有序选择容器。
  2. 插入/查找按对应数据结构定位。
  3. 遍历:HashMap 无序,BTreeMap 升序。

代码或图示

use std::collections::{HashMap, BTreeMap};
let mut h: HashMap<u32, &str> = HashMap::new();
h.insert(1, "a");
let mut b: BTreeMap<u32, &str> = BTreeMap::new();

常见误区

  • 以为 HashMap 遍历顺序稳定:顺序随哈希与插入变化,不应依赖。
  • 以为任何类型都能当键:自定义类型需派生/实现 Hash + Eq 或 Ord。

追问

  • 浮点能做 HashMap 键吗?答:f32/f64 不实现 Eq(NaN 不等),不能直接做键;需要时用整数化键或自定义包装。
  • 哈希冲突怎么处理?答:标准库 HashMap 内部处理桶与冲突链;负载因子与扩容由实现维护。

04.4.1.4-017 枚举 Option/Result 相比空指针/异常有什么安全优势?

一句话结论

Option/Result 把“缺失/失败”写进类型签名,调用方必须显式处理分支,编译器排除空指针解引用与未捕获异常;不需要运行时判空或异常表。

概念解释

空指针错误发生在运行时解引用点;异常需要调用方记得捕获。Rust 用枚举强制分支处理,遗漏 None/Err 即编译错误,错误路径在类型层面可见。

原理流程

  1. 返回类型标明可能缺失/失败。
  2. 取值前必须匹配或组合子处理。
  3. 未处理分支无法编译通过。

代码或图示

// 没有 null;可能缺失即 Option
let name: Option<&str> = ...;
match name { Some(n) => println!("{}", n), None => {} }

常见误区

  • 以为 Option 内部藏了空指针:它是枚举,Some 持有值或 None 变体。
  • 以为 Result 类似异常会自动上抛:它是普通返回值,需 ? 显式传播。

追问

  • 与 Java Optional 区别?答:Rust Option 是语言内建枚举,编译期强制处理;Java Optional 主要用作返回类型提示,不阻止 null 传入。
  • 错误上下文链如何保留?答:自定义错误/anyhow 保留 source 链,避免只看到最外层包装信息。

04.4.1.4-018 如何保留错误上下文与错误链?

一句话结论

在底层错误外包装领域错误并保留 source(),应用层用 context()/with_context 补充发生位置;输出时沿错误链逐层打印,避免错误信息丢失。

概念解释

裸向上抛字符串无法定位失败层级。正确做法:每层补充业务上下文,底层原因通过 source 链保留,日志/上报同时展示链路。

原理流程

  1. 底层 IO/解析错误被 From 纳入领域错误。
  2. 上层用 context 标注“在做什么操作时失败”。
  3. 格式化时遍历 source 输出完整链路。

代码或图示

use anyhow::Context;
let cfg = std::fs::read_to_string("cfg.toml")
    .with_context(|| "读取 cfg.toml 失败")?;

常见误区

  • 每一层都丢掉底层错误:只剩最外层消息,排查看不到根因。
  • 上下文只写泛化描述:应包含文件名、键、操作对象等可定位信息。

追问

  • 如何在日志里输出错误链?答:anyhow 用 {:#} 或 debug 格式打印链;标准错误类型沿 source() 递归收集。
  • 包装错误会不会影响调用方匹配?答:领域错误变体应保留可匹配类别,上下文包装放在应用边界,不破坏库错误类型语义。