Rust 迭代器（手把手讲解）

Rust 迭代器：让数据处理更优雅

在 Rust 编程中，处理集合数据是日常开发的核心任务之一。无论是遍历数组、筛选列表、转换数据，还是聚合结果，传统的 for 循环虽然能完成任务，但写起来容易冗长、重复，还容易出错。而 Rust 提供了一套强大的工具——Rust 迭代器，它不仅让代码更简洁，还提供了函数式编程的思维方式，极大提升了开发效率和代码可读性。

想象一下，你有一堆待处理的订单数据，要从中找出价格超过 100 元的订单，并计算它们的总金额。如果用传统的 for 循环，你需要写很多中间变量和判断逻辑。而使用 Rust 迭代器，你只需要几行代码，就能清晰表达“筛选 + 聚合”的意图。

今天，我们就深入聊聊 Rust 迭代器，从基础用法到高级技巧，一步步带你掌握这个强大的语言特性。

什么是迭代器？它为什么重要？

在编程中，迭代器是一种设计模式，用来遍历集合中的元素，而无需暴露底层数据结构的实现细节。Rust 的迭代器不是简单的 for 循环替代品，它是一个惰性求值（lazy evaluation）的系统，这意味着它不会立即执行操作，而是在你真正需要结果时才开始计算。

这就像点外卖：你下单时，厨房不会立刻开始做菜，而是等到你确认收货时才开始烹饪。这种“按需执行”的机制，让 Rust 迭代器在性能上非常高效。

在 Rust 中，所有集合类型（如 Vec、VecDeque、String 等）都实现了 IntoIterator trait，这意味着它们都可以被转换为迭代器。我们通过 .iter() 方法获取一个不可变引用的迭代器，.iter_mut() 获取可变引用的迭代器，.into_iter() 获取所有权的迭代器。

let numbers = vec![1, 2, 3, 4, 5];

// 获取不可变引用迭代器
let iter = numbers.iter();

// 遍历并打印每个元素
for num in iter {
    println!("{}", num);
}

注释：这里 numbers.iter() 返回一个 std::slice::Iter<i32> 类型的迭代器，它持有对 numbers 的不可变引用。for 循环会自动调用 Iterator trait 的 next 方法，依次取出元素，直到返回 None。

常用的迭代器方法详解

Rust 的标准库为迭代器提供了丰富的内置方法，这些方法让数据处理变得像流水线一样流畅。下面介绍几个最常用的。

filter：筛选符合条件的元素

filter 方法用于从迭代器中筛选出满足条件的元素。它接收一个闭包作为参数，返回 true 的元素会被保留。

let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 筛选出偶数
let even_numbers: Vec<i32> = numbers.iter()
    .filter(|&x| x % 2 == 0)
    .cloned()
    .collect();

println!("{:?}", even_numbers); // 输出: [2, 4, 6, 8, 10]

注释：filter(|&x| x % 2 == 0) 中，&x 是模式匹配，用于解引用指针（因为 iter() 返回的是 &i32）。x % 2 == 0 判断是否为偶数。cloned() 将 &i32 转为 i32，最后 collect() 将结果收集到 Vec 中。

map：对每个元素进行转换

map 方法用于将每个元素映射为新的值。常用于数据变换，比如将字符串转为大写，或对数值进行计算。

let words = vec!["hello", "world", "rust"];

// 将每个单词转为大写
let uppercase_words: Vec<String> = words.iter()
    .map(|s| s.to_uppercase())
    .collect();

println!("{:?}", uppercase_words); // 输出: ["HELLO", "WORLD", "RUST"]

注释：map(|s| s.to_uppercase()) 对每个字符串引用调用 to_uppercase() 方法，返回一个新的 String。注意：to_uppercase() 返回的是 String，所以最终类型是 Vec<String>。

fold：从迭代器中聚合值

fold 是一个强大的聚合方法，它接收一个初始值和一个闭包，用于逐步合并元素。常用于求和、拼接字符串、查找最大值等。

let numbers = vec![1, 2, 3, 4, 5];

// 计算总和
let sum = numbers.iter()
    .fold(0, |acc, x| acc + x);

println!("总和是: {}", sum); // 输出: 总和是: 15

注释：fold(0, |acc, x| acc + x) 中，0 是初始值（累加器），acc 是累加器，x 是当前元素。每次执行 acc + x，并更新 acc，直到遍历完成。

惰性求值：Rust 迭代器的性能优势

Rust 迭代器最核心的特性是惰性求值。这意味着当你链式调用多个迭代器方法时，它们并不会立即执行，而是在调用 collect()、for 循环等“终结方法”时才真正开始计算。

这就像你写了一串 SQL 查询，但数据库不会立刻执行，直到你执行 SELECT 时才查询数据。这种机制避免了不必要的中间计算，尤其在处理大数据时非常关键。

let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 惰性链式操作
let result: Vec<i32> = numbers.iter()
    .filter(|&x| x % 2 == 0)          // 筛选偶数
    .map(|x| x * 2)                  // 每个偶数乘以 2
    .filter(|&x| x > 10)             // 筛选大于 10 的
    .collect();                      // 最终收集结果

println!("{:?}", result); // 输出: [12, 16, 20]

注释：整个链式操作在 collect() 之前都不会执行。只有在 collect() 被调用时，才会从头到尾执行一遍。这种“流水线”式的处理方式，既高效又清晰。

自定义迭代器：深入底层

虽然标准库提供了丰富的迭代器方法，但有时你可能需要实现自己的迭代器。Rust 允许你通过实现 Iterator trait 来创建自定义迭代器。

例如，我们来实现一个生成斐波那契数列的迭代器：

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Fibonacci {
    fn new() -> Self {
        Fibonacci { curr: 0, next: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;
        let result = self.curr;

        self.curr = self.next;
        self.next = new_next;

        Some(result)
    }
}

// 使用自定义迭代器
fn main() {
    let fib = Fibonacci::new();

    // 取前 10 个斐波那契数
    let first_ten: Vec<u32> = fib.take(10).collect();

    println!("{:?}", first_ten);
    // 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
}

注释：Fibonacci 结构体保存当前和下一个值。next 方法返回 Option<u32>，当值为 None 时迭代结束。take(10) 限制只取前 10 个元素，collect() 收集结果。

实际案例：处理用户订单数据

让我们用一个真实场景来展示 Rust 迭代器的强大。假设我们有以下订单数据：

let orders = vec![
    Order { id: 1, amount: 120.0, status: "paid".to_string() },
    Order { id: 2, amount: 80.0, status: "pending".to_string() },
    Order { id: 3, amount: 150.0, status: "paid".to_string() },
    Order { id: 4, amount: 50.0, status: "cancelled".to_string() },
];

// 定义结构体
struct Order {
    id: u32,
    amount: f64,
    status: String,
}

// 需求：找出所有“已支付”且金额超过 100 的订单，并计算总金额
let total_paid_over_100: f64 = orders.iter()
    .filter(|order| order.status == "paid" && order.amount > 100.0)
    .map(|order| order.amount)
    .sum();

println!("已支付且金额大于 100 的订单总金额: {:.2}", total_paid_over_100);
// 输出: 已支付且金额大于 100 的订单总金额: 270.00

注释：filter 筛选条件，map 提取金额，sum() 是 Iterator 的内置方法，用于累加数值。整个逻辑清晰、简洁，几乎没有冗余代码。

总结与建议

Rust 迭代器是 Rust 语言中最具代表性的特性之一，它将函数式编程的思想融入系统编程语言中，既保证了性能，又提升了代码可读性。通过 filter、map、fold 等方法，你可以轻松实现复杂的数据处理逻辑。

掌握 Rust 迭代器，不仅让你写出更优雅的代码，还能帮助你理解现代编程中“声明式”与“命令式”编程的区别。建议初学者从 iter() + collect() 开始练习，逐步尝试链式调用，最后尝试实现自定义迭代器。

无论你是处理配置文件、解析日志，还是构建 Web 后端服务，Rust 迭代器都会是你最可靠的工具。真正理解并熟练使用它，是迈向高级 Rust 开发的重要一步。