Rust By Practice 迭代器实战指南:从 for 循环到自定义 Iterator
Rust By Practice 迭代器实战指南:从 for 循环到自定义 Iterator
迭代器(Iterator)是 Rust 函数式编程的基石:它把"遍历逻辑"抽象成惰性的数据序列,让代码更简洁、更安全、更易组合。本指南以 Rust By Practice 仓库的 iterator.md 为主体,逐层拆解 for 与迭代器的关系、Iterator trait 的 next 方法、into_iter/iter/iter_mut 三种转换方式的区别,并通过 12 道配套练习(含参考答案)带你亲手实现 Counter、Fibonacci 等自定义迭代器,最终掌握 sum、collect 等消费型适配器与 map、filter、zip 等惰性迭代器适配器的组合用法。
导读:本指南适合谁、能获得什么
Rust 初学者常把 for 当作普通循环,但 for 的本质是语法糖:它调用 into_iter 把集合转换成迭代器,再反复调用 next 直到返回 None。理解这条链路后,你将能够:
- 用
iter、iter_mut、into_iter精确控制"借用"与"所有权"语义,避免无谓的克隆与悬垂引用; - 通过实现
Iteratortrait 为自定义类型(如斐波那契数列)赋予遍历能力; - 用
map、filter、zip、collect、sum等适配器写出比手写循环更清晰、更不易出错的链式代码。
仓库中的所有练习均以 rust,editable 代码块呈现(可在网页上直接编辑运行),官方参考答案位于 solutions/functional-programing/iterator.md。下面我们按原文档的章节脉络逐一展开。
for 与迭代器:语法糖背后的真相
先看文档给出的最基础示例:
fn main() {
let v = vec![1, 2, 3];
for x in v {
println!("{}", x)
}
}
这段代码看起来只是一个简单循环,但实际上 for 正在对一个迭代器进行遍历。默认情况下,for 会对集合调用 into_iter 把它转换为迭代器。因此下面这段代码与上面的完全等价:
fn main() {
let v = vec![1, 2, 3];
for x in v.into_iter() {
println!("{}", x)
}
}
练习 1:用迭代器重构下标循环 🌟
把基于下标的 for i in 0..arr.len() 改写为直接迭代元素:
/* Refactoring the following code using iterators */
fn main() {
let arr = [0; 10];
for i in 0..arr.len() {
println!("{}", arr[i]);
}
}
参考答案:
fn main() {
let arr = [0; 10];
for i in arr {
println!("{}", i)
}
}
直接 for i in arr 即可让数组自身被转换为迭代器,不再需要下标访问,也从根本上杜绝了"越界"这类索引错误的可能。
练习 2:用区间构造迭代器 🌟
创建迭代器最简单的方式之一是使用区间(range)写法 a..b:
/* Fill in the blank */
fn main() {
let mut v = Vec::new();
for n in __ {
v.push(n);
}
assert_eq!(v.len(), 100);
}
要求 v.len() == 100,即区间应产生 100 个元素。参考答案为 1..101:
fn main() {
let mut v = Vec::new();
for n in 1..101 {
v.push(n);
}
assert_eq!(v.len(), 100);
}
注意 1..101 是左闭右开区间(包含 1、不包含 101),恰好产生 100 个元素。如果你想同时获得闭区间语义,可以使用 1..=100,效果相同。
next 方法:Iterator trait 的唯一必需方法
标准库中所有迭代器都实现了名为 Iterator 的 trait,其定义如下:
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
// Methods with default implementations elided
}
要点:
type Item是关联类型,声明迭代器产出的元素类型;fn next(&mut self) -> Option<Self::Item>是唯一必须实现的方法:迭代器每被调用一次next,就向前推进一步,返回Some(元素);当序列结束时返回None;- 其余所有方法(
map、filter、sum、collect等)都由标准库基于next提供了默认实现。
因此我们可以直接在迭代器上调用 next 方法,手动驱动遍历。
练习 3:手动调用 next 🌟🌟
/* Fill the blanks and fix the errors.
Using two ways if possible */
fn main() {
let v1 = vec![1, 2];
assert_eq!(v1.next(), __);
assert_eq!(v1.next(), __);
assert_eq!(v1.next(), __);
}
这里有两个坑:v1 没有声明为 mut,而 next 需要 &mut self;并且 vec 本身没有 next 方法,必须先转换成迭代器。参考答案给出了两种思路:
方式一:转移所有权(moving ownership)
fn main() {
let v1 = vec![1, 2];
// moving ownership
let mut v1_iter = v1.into_iter();
assert_eq!(v1_iter.next(), Some(1));
assert_eq!(v1_iter.next(), Some(2));
assert_eq!(v1_iter.next(), None);
}
方式二:借用(borrowing)
fn main() {
let v1 = vec![1, 2];
// borrowing
let mut v1_iter = v1.iter();
assert_eq!(v1_iter.next(), Some(&1));
assert_eq!(v1_iter.next(), Some(&2));
assert_eq!(v1_iter.next(), None);
}
注意两种方式返回值的差异:into_iter() 产出元素本身(Some(1)),而 iter() 产出元素的引用(Some(&1))。这正是下一节要深入区分的三种转换方式。
into_iter、iter 与 iter_mut:三种转换,三种所有权语义
前文提到 for 默认对集合调用 into_iter,但这并不是把集合转换成迭代器的唯一途径。into_iter、iter、iter_mut 都能完成转换,但方式截然不同:
| 方法 | 转换方式 | 集合在循环后的状态 | 产出的元素 |
|---|---|---|---|
into_iter |
消费(move)集合,所有权移入循环 | 集合不再可用 | 元素本身 T |
iter |
每次迭代借用集合的每个元素 | 集合未被触碰,循环后仍可复用 | 元素的不可变引用 &T |
iter_mut |
可变借用集合的每个元素 | 允许在循环内原地修改集合 | 元素的可变引用 &mut T |
用一句话概括:into_iter 转移所有权,iter 只读借用,iter_mut 可变借用。
练习 4:让 for 循环不消耗集合 🌟
/* Make it work */
fn main() {
let arr = vec![0; 10];
for i in arr {
println!("{}", i);
}
println!("{:?}", arr);
}
直接 for i in arr 会隐式调用 into_iter 把 arr 消耗掉,循环后再打印 arr 就会编译报错。改为借用即可:
fn main() {
let arr = vec![0; 10];
for i in arr.iter() {
println!("{}", i)
}
println!("{:?}", arr);
}
arr.iter() 只借用元素,循环结束后 arr 依然可用。
练习 5:用 iter_mut 原地修改 🌟
/* Fill in the blank */
fn main() {
let mut names = vec!["Bob", "Frank", "Ferris"];
for name in names.__ {
*name = match name {
&mut "Ferris" => "There is a rustacean among us!",
_ => "Hello",
}
}
println!("names: {:?}", names);
}
空处应填 iter_mut(),因为循环体内通过 *name 解引用修改了数组元素:
fn main() {
let mut names = vec!["Bob", "Frank", "Ferris"];
for name in names.iter_mut() {
*name = match name {
&mut "Ferris" => "There is a rustacean among us!",
_ => "Hello",
}
}
println!("names: {:?}", names);
}
如果这里误用 iter(),name 将是 &&str 类型,无法完成赋值修改;而 into_iter() 则会消耗掉 names,导致最后的打印失败。
练习 6:iter_mut + next 的组合 🌟🌟
/* Fill in the blank */
fn main() {
let mut values = vec![1, 2, 3];
let mut values_iter = values.__;
if let Some(v) = values_iter.__ {
__
}
assert_eq!(values, vec![0, 2, 3]);
}
目标是把 values 的第一个元素改成 0,同时不消耗整个集合。答案使用 iter_mut() 拿到可变迭代器,用 next() 取到第一个元素的可变引用并赋值为 0:
fn main() {
let mut values = vec![1, 2, 3];
let mut values_iter = values.iter_mut();
if let Some(v) = values_iter.next() {
*v = 0;
}
assert_eq!(values, vec![0, 2, 3]);
}
注意 values_iter 必须声明为 mut,因为 next 需要 &mut self;且 values 也必须是 mut,因为我们要借用它的可变引用。
创建自己的迭代器:实现 Iterator trait
我们不仅可以从集合类型创建迭代器,还可以通过为自己的类型实现 Iterator trait 来创建迭代器。文档给出的 Counter 示例展示了最完整的实现骨架:
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < 5 {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
fn main() {
let mut counter = Counter::new();
assert_eq!(counter.next(), Some(1));
assert_eq!(counter.next(), Some(2));
assert_eq!(counter.next(), Some(3));
assert_eq!(counter.next(), Some(4));
assert_eq!(counter.next(), Some(5));
assert_eq!(counter.next(), None);
}
可以看到,实现迭代器只需要两件事:声明 type Item(元素类型),以及实现 next 方法。Counter 在计数达到 5 后返回 None,从而标记序列结束。
练习 7:实现 Fibonacci 迭代器 🌟🌟🌟
struct Fibonacci {
curr: u32,
next: u32,
}
// Implement `Iterator` for `Fibonacci`.
// The `Iterator` trait only requires a method to be defined for the `next` element.
impl Iterator for Fibonacci {
// We can refer to this type using Self::Item
type Item = u32;
/* Implement next method */
fn next(&mut self)
}
// Returns a Fibonacci sequence generator
fn fibonacci() -> Fibonacci {
Fibonacci { curr: 0, next: 1 }
}
fn main() {
let mut fib = fibonacci();
assert_eq!(fib.next(), Some(1));
assert_eq!(fib.next(), Some(1));
assert_eq!(fib.next(), Some(2));
assert_eq!(fib.next(), Some(3));
assert_eq!(fib.next(), Some(5));
}
斐波那契数列是无限的,因此 next 永远不会返回 None。参考答案(solutions/functional-programing/iterator.md):
impl Iterator for Fibonacci {
// We can refer to this type using Self::Item
type Item = u32;
// Here, we define the sequence using `.curr` and `.next`.
// The return type is `Option<T>`:
// * When the `Iterator` is finished, `None` is returned.
// * Otherwise, the next value is wrapped in `Some` and returned.
// We use Self::Item in the return type, so we can change
// the type without having to update the function signatures.
fn next(&mut self) -> Option<Self::Item> {
let new_next = self.curr + self.next;
self.curr = self.next;
self.next = new_next;
// Since there's no endpoint to a Fibonacci sequence, the `Iterator`
// will never return `None`, and `Some` is always returned.
Some(self.curr)
}
}
这段实现有两个值得学习的细节:
- 返回值使用
Self::Item而非硬编码u32,后续如果要改元素类型(例如换成u64),只需修改关联类型定义,无需改动函数签名; - 通过
self.curr = self.next; self.next = new_next;完成序列状态的推进,语义清晰且无循环依赖。
消费型适配器(Consuming Adaptors)
Iterator trait 提供了大量带默认实现的方法。其中一部分方法会通过调用 next 来"用尽"迭代器,因此被称为消费型适配器(consuming adaptors)。典型代表是 sum 和 collect。
练习 8:sum 会消费迭代器 🌟🌟
/* Fill in the blank and fix the errors */
fn main() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
// The sum method will take the ownership of the iterator and iterates through the items by repeatedly calling next method
let total = v1_iter.sum();
assert_eq!(total, __);
println!("{:?}, {:?}", v1, v1_iter);
}
参考答案:
fn main() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
// The sum method will take the ownership of the iterator and iterates through the items by repeatedly calling next method
let total: i32 = v1_iter.sum();
assert_eq!(total, 6);
println!("{:?}", v1);
}
两个关键点:
sum通过反复调用next累加所有元素,因此会取得迭代器的所有权。v1_iter在调用sum后已被消费,不能再被打印,所以最终println!只能打印v1(v1.iter()只借用了元素,集合本身安然无恙);total需要显式标注类型(let total: i32),因为sum需要类型信息来确定累加目标类型。
练习 9:用 collect 收集为集合 🌟🌟
除了把集合转成迭代器,我们还可以用 collect 把迭代器产生的结果值收集回集合。collect 同样会消费迭代器。
/* Make it work */
use std::collections::HashMap;
fn main() {
let names = [("sunface", 18), ("sunfei", 18)];
let folks: HashMap<_, _> = names.into_iter().collect();
println!("{:?}", folks);
let v1: Vec<i32> = vec![1, 2, 3];
let v2 = v1.iter().collect();
assert_eq!(v2, vec![1, 2, 3]);
}
答案只需把第二处 collect 的目标类型补全为 Vec<_>:
use std::collections::HashMap;
fn main() {
let names = [("sunface", 18), ("sunfei", 18)];
let folks: HashMap<_, _> = names.into_iter().collect();
println!("{:?}", folks);
let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.into_iter().collect();
assert_eq!(v2, vec![1, 2, 3]);
}
collect 的目标类型由上下文推断:names 的元素是 (&str, i32) 元组,收集成 HashMap<_, _> 顺理成章;v1 的元素是 i32,收集成 Vec<_> 即可。
迭代器适配器(Iterator Adaptors)与惰性求值
把一种迭代器改造成另一种迭代器的方法称为迭代器适配器(iterator adaptors),例如 map(映射)、filter(过滤)、zip(配对)。你可以把多个适配器链式串联,以可读的方式完成复杂操作。
但请注意:所有迭代器都是惰性的(lazy)。仅仅调用适配器不会执行任何计算,你必须调用 sum、collect 等消费型适配器,才能真正驱动迭代、拿到结果。
练习 10:map + collect 链 🌟🌟
/* Fill in the blanks */
fn main() {
let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().__.__;
assert_eq!(v2, vec![2, 3, 4]);
}
目标是把每个元素加 1。参考答案:
fn main() {
let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
assert_eq!(v2, vec![2, 3, 4]);
}
这里 map(|x| x + 1) 是适配器,collect() 是驱动计算的消费型方法,二者缺一不可。由于 v1.iter() 产生的是 &i32,闭包参数 x 实为引用,x + 1 会自动解引用计算。
练习 11:zip 配对两个迭代器 🌟🌟
/* Fill in the blanks */
use std::collections::HashMap;
fn main() {
let names = ["sunface", "sunfei"];
let ages = [18, 18];
let folks: HashMap<_, _> = names.into_iter().__.collect();
println!("{:?}", folks);
}
zip 会把两个迭代器按位置配对成 (键, 值) 元组流,再交给 collect 收进 HashMap:
use std::collections::HashMap;
fn main() {
let names = ["sunface", "sunfei"];
let ages = [18, 18];
let folks: HashMap<_, _> = names.into_iter().zip(ages.into_iter()).collect();
println!("{:?}", folks);
}
运行后会得到 {"sunface": 18, "sunfei": 18}。zip 生成的迭代器长度取两个输入迭代器的较短者。
练习 12:在适配器中用闭包过滤 🌟🌟
/* Fill in the blanks */
#[derive(PartialEq, Debug)]
struct Shoe {
size: u32,
style: String,
}
fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
shoes.into_iter().__.collect()
}
fn main() {
let shoes = vec![
Shoe { size: 10, style: String::from("sneaker") },
Shoe { size: 13, style: String::from("sandal") },
Shoe { size: 10, style: String::from("boot") },
];
let in_my_size = shoes_in_size(shoes, 10);
assert_eq!(
in_my_size,
vec![
Shoe { size: 10, style: String::from("sneaker") },
Shoe { size: 10, style: String::from("boot") },
]
);
}
答案是在 into_iter() 之后链上 filter,闭包捕获外部参数 shoe_size(这正是闭包相对普通函数的核心优势之一,详见同一章节的 closure.md):
fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}
filter 接收一个返回 bool 的闭包,保留返回 true 的元素。注意 filter 传入的是元素的引用(|s| 中 s: &Shoe),因此用 s.size 而非 s.size 的移动语义访问字段是安全且无所有权的。
源码佐证:迭代器在真实项目中的运用
迭代器并非只出现在练习里。仓库自带的 mini-redis 示例项目(位于 zh-CN/assets/mini-redis)就是一个真实使用迭代器处理业务逻辑的案例。例如在 db.rs 中:
- 读取键值数据时用
state.entries.get(key).map(|entry| entry.data.clone())(db.rs 第 159 行),Option::map本质上就是迭代器的表亲——只对Some生效的映射; - 移除过期键时使用
state.expirations.iter().next()(db.rs 第 318 行)取出迭代器的下一个元素,配合while let循环逐个处理; - 向订阅者广播消息时用
map(|tx| tx.send(value).unwrap_or(0))(db.rs 第 274 行)把发送结果映射为统计数值。
这些真实调用印证了文档中的核心论断:无论是 map 的映射、iter().next() 的手动驱动,还是 collect 式的收集,迭代器的使用贯穿于"集合 → 处理 → 结果"的全链路,且几乎不会产生额外的手写循环噪音。
小结:一张表记住迭代器的核心心智模型
| 概念 | 关键方法/行为 | 是否消费迭代器 | 典型场景 |
|---|---|---|---|
| 语法糖 | for x in iter 等价于 iter.into_iter() + 反复 next |
是(into_iter) |
最简单、最安全的遍历 |
| 核心 trait | Iterator::next -> Option<Item> |
逐次推进 | 手动控制遍历节奏 |
| 三种转换 | into_iter / iter / iter_mut |
转移所有权 / 不可变借用 / 可变借用 | 按是否需要复用集合选择 |
| 消费型适配器 | sum、collect |
是(调用后迭代器不可再用) | 求和、收集结果集 |
| 迭代器适配器 | map、filter、zip |
否(惰性,需消费型方法驱动) | 链式变换与过滤 |
想系统刷完本节的 12 道题,直接打开 iterator.md 逐题练习;卡住时参考 solutions/functional-programing/iterator.md 的完整答案。掌握迭代器之后,建议接着学习同一章节的 closure.md,因为 map、filter 等适配器的核心参数正是闭包——两者结合,才是完整的 Rust 函数式编程能力。