使用迭代器处理一系列项目

迭代器模式允许你依次对一系列项目执行某些任务。迭代器负责遍历每个项目的逻辑以及确定序列何时结束。当你使用迭代器时，你不必自己重新实现该逻辑。

在 Rust 中，迭代器是惰性的，这意味着直到你调用消耗迭代器的方法来使用它之前，它们没有任何效果。例如，清单 13-10 中的代码通过调用定义在 Vec<T> 上的 iter 方法创建了一个遍历向量 v1 中项的迭代器。这段代码本身并没有什么实际用途。

Filename: src/main.rs 
fn main() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();
}
Listing 13-10: Creating an iterator

迭代器存储在 v1_iter 变量中。一旦我们创建了一个迭代器，我们就可以以多种方式使用它。在第 3 章的示例 3-5 中，我们使用 for 循环遍历数组，以对每个元素执行一些代码。在幕后，这隐式地创建并消耗了一个迭代器，但直到现在我们才详细说明它是如何工作的。

在示例 13-11 中，我们将迭代器的创建与在 for 循环中使用迭代器分离开来。当使用 v1_iter 中的迭代器调用 for 循环时，迭代器中的每个元素都会在循环的一次迭代中被使用，从而打印出每个值。

Filename: src/main.rs 
fn main() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {val}");
    }
}
Listing 13-11: Using an iterator in a for loop

在没有迭代器的标准库提供的语言中，你可能会通过从索引 0 开始一个变量，使用该变量来索引向量以获取值，并在循环中递增变量值直到达到向量中的总项目数来编写相同的功能。

迭代器为您处理所有这些逻辑，减少了可能会出错的重复代码。迭代器使您能够更灵活地使用相同的逻辑处理许多不同类型的序列，而不仅仅是您可以索引的数据结构，如向量。让我们看看迭代器是如何做到这一点的。

《Iterator 特性与 next 方法》

所有迭代器都实现了标准库中定义的一个名为 Iterator 的特征。该特征的定义如下：

#![allow(unused)]
fn main() {
pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // methods with default implementations elided
}
}

注意这个定义使用了一些新的语法：type Item 和 Self::Item，它们是在这个特质中定义一个 关联类型。我们将在第 20 章详细讨论关联类型。现在，你只需要知道这段代码表示实现 Iterator 特质需要你定义一个 Item 类型，并且这个 Item 类型用于 next 方法的返回类型。换句话说，Item 类型将是迭代器返回的类型。

Iterator 特性只需要实现者定义一个方法：next 方法，该方法每次返回迭代器的一个项，包装在 Some 中，当迭代结束时，返回 None。

我们可以直接在迭代器上调用 next 方法；列表 13-12 展示了从向量创建的迭代器中重复调用 next 返回的值。

Filename: src/lib.rs 
#[cfg(test)]
mod tests {
    #[test]
    fn iterator_demonstration() {
        let v1 = vec![1, 2, 3];

        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(), Some(&3));
        assert_eq!(v1_iter.next(), None);
    }
}
Listing 13-12: Calling the next method on an iterator

请注意，我们需要将 v1_iter 设为可变的：在迭代器上调用 next 方法会改变迭代器用于跟踪其在序列中位置的内部状态。换句话说，这段代码 消耗，或用尽了迭代器。每次调用 next 都会从迭代器中消耗一个项目。当我们使用 for 循环时，不需要将 v1_iter 设为可变的，因为循环会获取 v1_iter 的所有权，并在幕后将其设为可变的。

还请注意，从 next 调用中获得的值是对向量中值的不可变引用。 iter 方法生成一个遍历不可变引用的迭代器。如果我们想创建一个获取 v1 所有权并返回拥有值的迭代器，我们可以调用 into_iter 而不是 iter。同样，如果我们想遍历可变引用，我们可以调用 iter_mut 而不是 iter。

消耗迭代器的方法

Iterator 特性有许多由标准库提供的默认实现的方法；你可以通过查看标准库 API 文档中的 Iterator 特性来了解这些方法。其中一些方法在其定义中调用了 next 方法，这就是为什么在实现 Iterator 特性时需要实现 next 方法的原因。

调用 next 的方法被称为 消耗适配器，因为调用它们会用尽迭代器。一个例子是 sum 方法，它获取迭代器的所有权并通过反复调用 next 遍历项目，从而消耗迭代器。在遍历过程中，它将每个项目添加到累加总数中，并在遍历完成后返回总数。列表 13-13 有一个测试说明了 sum 方法的使用：

Filename: src/lib.rs 
#[cfg(test)]
mod tests {
    #[test]
    fn iterator_sum() {
        let v1 = vec![1, 2, 3];

        let v1_iter = v1.iter();

        let total: i32 = v1_iter.sum();

        assert_eq!(total, 6);
    }
}
Listing 13-13: Calling the sum method to get the total of all items in the iterator

我们不能在调用 sum 之后使用 v1_iter，因为 sum 会获取我们调用它的迭代器的所有权。

生成其他迭代器的方法

迭代器适配器 是定义在 Iterator 特性上的方法，它们不会消耗迭代器。相反，它们通过改变原始迭代器的某些方面来生成不同的迭代器。

列表13-14展示了调用迭代器适配器方法map的示例，该方法在迭代过程中对每个项目调用一个闭包。 map方法返回一个新的迭代器，该迭代器生成修改后的项目。这里的闭包创建了一个新的迭代器，其中向量中的每个项目都将增加1：

Filename: src/main.rs 
fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];

    v1.iter().map(|x| x + 1);
}
Listing 13-14: Calling the iterator adapter map to create a new iterator

然而，这段代码会产生一个警告：

$ cargo run
   Compiling iterators v0.1.0 (file:///projects/iterators)
warning: unused `Map` that must be used
 --> src/main.rs:4:5
  |
4 |     v1.iter().map(|x| x + 1);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: iterators are lazy and do nothing unless consumed
  = note: `#[warn(unused_must_use)]` on by default
help: use `let _ = ...` to ignore the resulting value
  |
4 |     let _ = v1.iter().map(|x| x + 1);
  |     +++++++

warning: `iterators` (bin "iterators") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.47s
     Running `target/debug/iterators`

列表 13-14 中的代码什么也不做；我们指定的闭包从未被调用。警告提醒我们原因：迭代器适配器是惰性的，我们需要在这里消耗迭代器。

要修复此警告并使用迭代器，我们将使用collect方法，我们在第12章的示例12-1中使用了env::args时也用过此方法。此方法会消耗迭代器并将结果值收集到集合数据类型中。

在清单 13-15 中，我们将从调用 map 返回的迭代器上迭代的结果收集到一个向量中。这个向量最终将包含原始向量中的每个元素加 1 后的结果。

Filename: src/main.rs 
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]);
}
Listing 13-15: Calling the map method to create a new iterator and then calling the collect method to consume the new iterator and create a vector

因为 map 接受一个闭包，我们可以指定要对每个项目执行的任何操作。这是闭包如何让你在重用 Iterator 特性提供的迭代行为的同时，自定义某些行为的一个很好的例子。

您可以将多个迭代器适配器的调用链在一起，以可读的方式执行复杂的操作。但由于所有迭代器都是惰性的，您必须调用其中一个消耗适配器方法才能从迭代器适配器的调用中获取结果。

使用捕获其环境的闭包

许多迭代器适配器接受闭包作为参数，通常我们指定为迭代器适配器的参数的闭包将是捕获其环境的闭包。

对于这个例子，我们将使用 filter 方法，该方法接受一个闭包。闭包从迭代器中获取一个项并返回一个 bool。如果闭包返回 true，该值将被包含在 filter 生成的迭代中。如果闭包返回 false，该值将不会被包含。

在清单 13-16 中，我们使用 filter 与一个捕获其环境中的 shoe_size 变量的闭包来遍历 Shoe 结构体实例的集合。它将仅返回指定尺寸的鞋子。

Filename: src/lib.rs 
#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn filters_by_size() {
        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")
                },
            ]
        );
    }
}
Listing 13-16: Using the filter method with a closure that captures shoe_size

shoes_in_size 函数接受一个鞋子向量和一个鞋子尺寸作为参数。它返回一个仅包含指定尺寸鞋子的向量。

在 shoes_in_size 的主体中，我们调用 into_iter 来创建一个迭代器，该迭代器获取向量的所有权。然后我们调用 filter 来将该迭代器适配为一个新的迭代器，该迭代器仅包含闭包返回 true 的元素。

闭包从环境中捕获 shoe_size 参数，并将该值与每双鞋的尺寸进行比较，只保留指定尺寸的鞋。最后，调用 collect 将适配器迭代器返回的值收集到一个向量中，该向量由函数返回。

测试显示，当我们调用shoes_in_size时，我们只会得到与我们指定的值大小相同的鞋子。