使用迭代器处理一系列项目
迭代器模式允许您依次对一系列项目执行某些任务。迭代器负责迭代每个项目并确定序列何时完成的逻辑。当您使用迭代器时，您不必自己重新实现该逻辑。
在 Rust 中，迭代器是*惰性*的，这意味着它们在您调用消耗迭代器以将其用尽的方法之前没有任何作用。例如，清单 13-10 中的代码通过调用在 `Vec<T>` 上定义的 `iter` 方法来创建向量 `v1` 中项目上的迭代器。这段代码本身不做任何有用的事情。
fn main() { let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); }
清单 13-10：创建迭代器
迭代器存储在 `v1_iter` 变量中。创建迭代器后，我们可以通过多种方式使用它。在第 3 章的清单 3-5 中，我们使用 `for` 循环迭代数组以对其每个项目执行一些代码。在底层，这隐式地创建然后消耗了一个迭代器，但我们直到现在才详细说明它是如何工作的。
在清单 13-11 的示例中，我们将迭代器的创建与 `for` 循环中迭代器的使用分开。当使用 `v1_iter` 中的迭代器调用 `for` 循环时，迭代器中的每个元素都在循环的一次迭代中使用，从而打印出每个值。
fn main() { let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); for val in v1_iter { println!("Got: {val}"); } }
清单 13-11：在 `for` 循环中使用迭代器
在标准库中没有提供迭代器的语言中，您可能会通过在索引 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`，它们使用此特征定义了*关联类型*。我们将在第 19 章中深入讨论关联类型。现在，您只需要知道这段代码表示实现 `Iterator` 特征需要您还定义一个 `Item` 类型，并且此 `Item` 类型在 `next` 方法的返回类型中使用。换句话说，`Item` 类型将是从迭代器返回的类型。
Iterator trait 只要求实现者定义一个方法：next 方法，该方法返回迭代器中的一项，该项包装在 Some 中，当迭代结束时，返回 None。
我们可以直接在迭代器上调用 next 方法；清单 13-12 演示了在从向量创建的迭代器上重复调用 next 时返回的值。
文件名：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);
}
}清单 13-12：在迭代器上调用 next 方法
注意，我们需要将 v1_iter 设为可变的：在迭代器上调用 next 方法会改变迭代器用来跟踪其在序列中位置的内部状态。换句话说，这段代码_消耗_或用尽了迭代器。每次调用 next 都会从迭代器中消耗一项。当我们使用 for 循环时，我们不需要将 v1_iter 设为可变的，因为循环获取了 v1_iter 的所有权，并在幕后将其设为可变的。
还要注意，我们从 next 调用中获得的值是对向量中值的不可变引用。iter 方法生成一个对不可变引用的迭代器。如果我们想创建一个迭代器，它获取 v1 的所有权并返回拥有的值，我们可以调用 into_iter 而不是 iter。类似地，如果我们想迭代可变引用，我们可以调用 iter_mut 而不是 iter。
消耗迭代器的方法
Iterator trait 有许多不同的方法，标准库提供了默认实现；您可以通过查看标准库 API 文档中关于 Iterator trait 的内容来了解这些方法。其中一些方法在其定义中调用了 next 方法，这就是为什么在实现 Iterator trait 时需要实现 next 方法的原因。
调用 next 的方法称为_消耗适配器_，因为调用它们会用尽迭代器。一个例子是 sum 方法，它获取迭代器的所有权，并通过重复调用 next 来迭代项目，从而消耗迭代器。在迭代过程中，它将每个项目添加到一个运行总数中，并在迭代完成时返回总数。清单 13-13 中有一个测试，说明了 sum 方法的使用
文件名：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);
}
}清单 13-13：调用 sum 方法获取迭代器中所有项目的总和
在调用 sum 之后，我们不能再使用 v1_iter，因为 sum 获取了我们调用它的迭代器的所有权。
生成其他迭代器的方法
_迭代器适配器_是在 Iterator trait 上定义的方法，它们不消耗迭代器。相反，它们通过改变原始迭代器的某些方面来生成不同的迭代器。
清单 13-14 显示了一个调用迭代器适配器方法 map 的示例，该方法接受一个闭包，在迭代项目时对每个项目进行调用。map 方法返回一个新的迭代器，该迭代器生成修改后的项目。这里的闭包创建了一个新的迭代器，其中向量中的每个项目都将增加 1
文件名：src/main.rs
fn main() { let v1: Vec<i32> = vec![1, 2, 3]; v1.iter().map(|x| x + 1); }
清单 13-14：调用迭代器适配器 map 来创建一个新的迭代器
但是，这段代码会产生一个警告
$ 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 [unoptimized + debuginfo] target(s) in 0.47s
Running `target/debug/iterators`
清单 13-14 中的代码什么也不做；我们指定的闭包从未被调用过。警告提醒我们为什么：迭代器适配器是惰性的，我们需要在这里消耗迭代器。
为了修复这个警告并消耗迭代器，我们将使用 collect 方法，我们在第 12 章中使用 env::args 在清单 12-1 中使用了该方法。这个方法消耗迭代器，并将结果值收集到一个集合数据类型中。
在清单 13-15 中，我们将迭代从 map 调用返回的迭代器的结果收集到一个向量中。这个向量最终将包含原始向量中每个增加 1 的项目。
文件名：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]); }
清单 13-15：调用 map 方法创建一个新的迭代器，然后调用 collect 方法消耗新的迭代器并创建一个向量
因为 map 接受一个闭包，所以我们可以指定我们想对每个项目执行的任何操作。这是一个很好的例子，说明了闭包如何让您自定义某些行为，同时重用 Iterator trait 提供的迭代行为。
您可以链接对迭代器适配器的多次调用，以可读的方式执行复杂的操作。但是，因为所有迭代器都是惰性的，所以您必须调用其中一个消耗适配器方法来从对迭代器适配器的调用中获得结果。
使用捕获其环境的闭包
许多迭代器适配器都将闭包作为参数，通常我们将指定为迭代器适配器参数的闭包将是捕获其环境的闭包。
对于这个例子，我们将使用 filter 方法，它接受一个闭包。闭包从迭代器中获取一个项目，并返回一个 bool。如果闭包返回 true，则该值将包含在 filter 生成的迭代中。如果闭包返回 false，则该值将不包含在内。
在清单 13-16 中，我们将 filter 与一个闭包一起使用，该闭包从其环境中捕获 shoe_size 变量，以迭代 Shoe 结构体实例的集合。它将只返回指定尺寸的鞋子。
文件名：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")
},
]
);
}
}清单 13-16：将 filter 方法与捕获 shoe_size 的闭包一起使用
shoes_in_size 函数获取鞋子的向量和鞋子尺寸作为参数。它返回一个只包含指定尺寸鞋子的向量。
在 shoes_in_size 的主体中，我们调用 into_iter 来创建一个迭代器，该迭代器获取向量的所有权。然后我们调用 filter 来将该迭代器适配成一个新的迭代器，该迭代器只包含闭包返回 true 的元素。
闭包从环境中捕获 shoe_size 参数，并将其值与每只鞋子的尺寸进行比较，只保留指定尺寸的鞋子。最后，调用 collect 将适配后的迭代器返回的值收集到一个向量中，该向量由函数返回。
测试表明，当我们调用 shoes_in_size 时，我们只得到与我们指定的值相同尺寸的鞋子。