Rust By Practice 迭代器实战指南:从 for 循环到自定义 Iterator

原创2026-09-21 21:55:471,635 阅读
文章标签:教程文档示例工程

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 精确控制"借用"与"所有权"语义,避免无谓的克隆与悬垂引用;
  • 通过实现 Iterator trait 为自定义类型(如斐波那契数列)赋予遍历能力;
  • 用 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 函数式编程能力。

登录后查看全文
rust-by-practice