@@ -1,43 +1,43 @@
# 以迭代器处理一系列项目
迭代器模式， 个 任务。迭代器负责对各个条目遍历， 及判断序列何时结束的逻辑。咱们运用了迭代器后，就不必自己再实现那个 逻辑。
迭代器模式允许咱们依次对一系列项目 执行某些 任务。所谓 迭代器， 遍历每个项目以 及判断序列何时结束的逻辑。当 咱们使用迭代器时，咱们不必自己重新实现该 逻辑。
在 Rust 中，迭代器是 * 惰性的， * ，这意味着在咱们调用消费该 迭代器的方法， 完 前，他们没有 任何效果。例如，下面清单 13-10 中的代码， `Vec<T>` 上的 `iter` 方法，而在 矢量 `v1` 中的项目上创建了一个 迭代器。这段代码本身并不做 任何有用的事情。
在 Rust 中，迭代器是 * 懒惰的 * ，这意味着在咱们调用消费迭代器的方法将其用尽之 前，他们不会产生 任何效果。例如，下面清单 13-10 中的代码通过调用定义在 `Vec<T>` 上的 `iter` 方法，创建一个遍历 矢量值 `v1` 中的项目的 迭代器。这段代码本身并不会完成 任何有用的事情。
<a name="listing_13-10"></a>
``` rust
let v1 = vec! [ 1 , 2 , 3 ] ;
let v1_iter = v1 . iter ( ) ;
```
* ： *
** 清单 13-10**
迭代器被 存储在变量 `v1_iter` 中。一旦咱们已 创建出 迭代器，就能 以多种方式使用他。在第 3 章中的清单 3-5 中，就曾 使用了 `for` 循环，对数组进行迭代，而在该数组的各个条目上执行代码。在使用 `for` 循环表象下，便是隐式地创建出迭代器，并随后消费 迭代器，但直到现在，我们都未提及其 原理。
迭代器存储在变量 `v1_iter` 中。一旦我们 创建了 迭代器，就可 以多种方式使用他。在 [清单 3-5 ](../programming_concepts/control_flow.md#listing_3-5 ) 中，我们 使用 `for` 循环遍历了一个数组，以对其每个项目执行一些代码。在底层，这隐式地创建然后消费了一个 迭代器，但直到现在，我们才详细探讨其工作 原理。
下面清单 13-11 中的示例里，咱 们把迭代器的创建， `for` 循环中迭代器 的使用分离开了 。当使用 `v1_iter` 中的迭代器， `for` 循环时，迭代器中的各 个元素， 每 次迭代中被 使用，这就 打印出了各 个值。
下面清单 13-11 中的示例中，我 们把迭代器的创建与 `for` 循环中的使用分离。当使用 `v1_iter` 中的迭代器调用 `for` 循环时，迭代器中的每 个元素就会在循环的一 次迭代中使用，从而 打印出每 个值。
<a name="listing_13-11"></a>
``` rust
let v1 = vec! [ 1 , 2 , 3 ] ;
let v1_iter = v1 . iter ( ) ;
for val in v1_iter {
println! ( " 得到了 ： {} " , val ;
println! ( " 得到： {val } " ) ;
}
```
* ：于 `for` 循环中使用迭代器*
** 清单 13-11** ：在
在不具备由其 标准库提供的迭代器的编程 语言中，咱们很可能通过从 `0` 开始 开始一个索引变量，使用那 个变量索引到 矢量值中来获取到 一个值，并 在循环中对 递增索引 变量值，直到索引变量 达到矢量条目总数为止，而编写出这个同样 功能。
在没有 标准库提供的迭代器的语言中，咱们通常需要通过 开始一个索引 0 处的 变量，使用这 个变量索引进入 矢量值中来获取一个值，然后 在循环中递增该 变量值，直到其 达到矢量中的 条目总数，来编写这一相同 功能。
迭代器为你 处理所有这些逻辑，减少了 咱们可能会 搞砸的重复性 代码。不只咱们可以索引的数据结构，比如矢量值，对于许多不同类别的序列，迭代器都给了我们运用同样逻辑的更多灵活性。咱 们来看看迭代器是如何做到的。
迭代器为咱们 处理了 所有这些逻辑，从而 减少咱们可能搞砸的重复代码。迭代器给予咱们更大的灵活性，以对许多不同类别的序列使用这同一逻辑，而不仅仅像矢量值那样咱们可以索引的数据结构。我 们来看看迭代器是如何做到这一点 的。
## `Iterator` 特质与 `next` 方法
**The `Iterator` Trait and the `next` Method **
所有迭代器都实现了在标准库中定义的名为 `Iterator` 的特质。该特质的定义看起来像这样：
所有迭代器都实现了定义在标准库中的名为 `Iterator` 的特质。该特质的定义看起来像下面这样：
``` rust
@@ -46,16 +46,17 @@ pub trait Iterator {
fn next ( & mut self ) -> Option < Self ::Item > ;
// 这里省略了 有着默认实现的方法
// 有着默认实现的方法已省略
}
```
请注意此 定义使用了一些新语法：`type Item` 与 `Self::Item` ，他们定义着此 特质下的一个 * 关联类型， * 。在 19 章中，咱们将深入谈及关联类型。至于现在， 咱们只需清楚 这段代码表明， `Iterator` 特质需要咱们同时定义一个 `Item` 类型，而这个 `Item` 类型会在 `next` 方法返回值 类型中用到。也就是说 ， `Item` 类型将是迭代器返回的类型。
请注意，这个 定义使用了一些新语法：`type Item` 与 `Self::Item` ，他们定义了这个 特质下的 * 关联类型* 。我们将在第 20 章中深入探讨关联类型。目前 咱们只需知道， 这段代码表明实现 `Iterator` 特质需要咱们同时定义一个 `Item` 类型，而这个 `Item` 类型会用于 `next` 方法的 返回类型中。换言之 ， `Item` 类型将是自 迭代器返回的类型。
`Iterator` 特质只需要实现者， ， 定义一个方法：即 `next` 方法，该方法 会一次返回一个封 装在 `Some` 中的迭代器条目 ，当迭代完毕时，就会 返回 `None` 。
`Iterator` 特质仅要求实现者 定义一个方法：`next` 方法，他 会一次返回迭代器的一个项目，包 装在 `Some` 中，当迭代完毕时，返回 `None` 。
咱 们可以直接调用迭代器上的 `next` 方法；下面清单 13-12 演示了，在自 矢量创建出 的迭代器上， 反复调用 `next` 方法， 会返回的 值。
我 们可以直接调用对 迭代器调用 `next` 方法；下面清单 13-12 演示了对从 矢量创建的迭代器反复调用 `next` 会返回哪些 值。
<a name="listing_13-12"></a>
文件名：`src/lib.rs`
``` rust
@@ -72,23 +73,20 @@ fn iterator_demonstration() {
}
```
* ：调用迭代器上的 `next` 方法*
** 清单 13-12** ：对迭代器调用
请注意，我们需要构造 `v1_iter` 为可变：调用迭代器上的 `next` 方法会修改迭代器的内部状态，迭代器用于追踪其位于序列中何处。换句话说，这段代码 * 消费 * 或用完迭代器。每次调用 `next` 都会吃掉迭代器中的一个项目。当我们使用 `for` 循环时，我们不需要使 `v1_iter` 可变，因为循环取得了 `v1_iter` 的所有权并在幕后使其可变。
请注意咱们需将 `v1_iter` 构造为可变：调用迭代器上的 `next` 方法，会修改迭代器用来追踪其位于序列中何处的内部状态。换句话说，这段代码 * 消费， * ， ， ， `next` 的调用，都会吃掉迭代器的一个条目。在咱们使用 `for` 循环时，之所以不需要将 `v1_iter` 构造为可变，是由于那个循环取得了 `v1_iter` 的所有权，而在幕后将其构造为了可变 。
还要注意咱们从 `next` 的调用获取到值，都是到矢量中值的不可变引用。`iter` 方法会产生对不可变引用的迭代器。若咱们打算创建出取得 `v1` 所有权，并返回有所有权的数据时，咱们可以调用 `into_iter` 而非 `iter` 。与此类似，若咱们打算对可变引用迭代，咱们可以调用 `iter_mut` 而非 `iter` 。
还要注意，我们从调用 `next` 获取的值，属于对矢量中的值的不可变引用。`iter` 方法会生成一个对不可变引用的迭代器。当我们打算创建一个会取得 `v1` 的所有权并返回自有的值时，我们可以调用 `into_iter` 而不是 `iter` 。同样的，当我们打算遍历可变引用时，可以调用 `iter_mut` 而不是 `iter` 。
## 消费迭代器的方法
**Methods that Consume the Iterator **
`Iterator` 特质有着数个带有标准库提供的默认实现的不同方法；咱们可以通过查阅 `Iterator` 特质的标准库 API 文档，了解这些方法。其中一些方法在他们的定义中调用 `next` 方法，这就是为什么在实现 `Iterator` 特质时，咱们需要实现 `next` 方法。
调用 `next` 的方法称为 * 消费适配器， * ，因为调用他们会耗尽迭代器。一个例子是 `sum` 方法，他会取得迭代器的所有权，并通过重复调用 `next` 方法来迭代项目，从而消费迭代器。在遍历过程中，他会把每个条目加到一个运行总和，并在迭代完成后返回总和。下面清单 13-13有个测试， `sum` 方法的用法：
`Iterator` 特质有着数个不同的，带有由标准库提供默认实现的方法；通过查阅 `Iterator` 特质的标准库 API 文档，咱们便可找到这些方法。其中一些方法，在他们的定义中会调用 `next` 方法，这就是为什么在实现 `Iterator` 特质时需要实现 `next` 方法的原因。
调用 `next` 的方法称为 * 消费适配器， * ，因为调用它们会耗尽迭代器。一个例子是 `sum` 方法，他会获取迭代器的所有权并通过重复调用 `next` 方法来迭代项目，从而消费迭代器。在迭代过程中，他会把每个条目，加到一个运行中的总和，并在遍历完成时返回总和。下面清单 13-13， `sum` 方法运用的测试：
<a name="listing_13-13"></a>
文件名：`src/lib.rs`
``` rust
@@ -104,20 +102,19 @@ fn iterator_sum() {
}
```
* ： 来 获取迭代器中全部 项目的总和*
** 清单 13-13** 所有 项目的总和
由于 `sum` 取得了咱们于其上调用他的迭代器所有权，因此在 `sum` 的调用后，就不允许使用 `v1_iter` 了 。
我们不允许在调用 `sum` 之后再使用 `v1_iter` ，因为 `sum` 取我们对其调用他的迭代器的所有权 。
## 产生出 其他迭代器的方法
## 产生其他迭代器的方法
**Iterators that Produce Other Iterators **
所谓 * 迭代器适配器， * ，属于一些定义在 `Iterator` 特质中的方法，他们不消费迭代器。相反，他们通过修改原始迭代器的某些方面而生成不同的迭代器。
下面清单 13-14 展示了调用迭代器适配器方法 `map` 的一个示例，其取一个闭包，在遍历迭代器项目时对每个项目调用该闭包。`map` 方法返回一个新的迭代器，生成修改后的项目。这里的闭包创建了一个新的迭代器，其中矢量值的每个项目都将增加 1：
* 迭代器适配器， * 是定义在 `Iterator` 特质上，不会消费迭代器的方法。相反，他们会通过改变初始迭代器的某一方面，而产生出另一迭代器。
下面清单 13-17 给出了调用迭代器适配器方法 `map` 的示例，其会取迭代器条目被遍历时，在各个条目上调用的一个闭包。`map` 方法会返回产生出修改后条目的新迭代器。这里的闭包创建了一个新的迭代器，其中原矢量的各个条目都增加了 `1` ：
<a name="listing_13-14"></a>
文件名：`src/main.rs`
``` rust
@@ -126,33 +123,38 @@ fn iterator_sum() {
v1 . iter ( ) . map ( | x | x + 1 ) ;
```
* ： 出 新迭代器*
** 清单 13-14** 的 迭代器
然而，此 代码会 产生一条告警：
然而，这段 代码产生了 一条告警：
``` console
$ cargo run lennyp@vm-manjaro
Compiling iterator_demo v0.1.0 (/home/lennyp /rust-lang/iterator_demo )
$ cargo run
Compiling iterators v0.1.0 (/home/hector /rust-lang-zh_CN/projects /iterators )
warning: unused `Map` that must be used
--> src/main.rs:4:5
|
4 | v1.iter().map(|x| x + 1);
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: iterators are lazy and do nothing unless consumed
= note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
|
4 | let _ = v1.iter().map(|x| x + 1);
| +++++++
warning: `iterator_demo ` (bin "iterator_demo ") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.36 s
Running `target/debug/iterator_demo `
warning: `iterators ` (bin "iterators ") generated 1 warning
Finished ` dev` profile [unoptimized + debuginfo] target(s) in 0.07 s
Running `target/debug/iterators `
```
清单 13-14 中的代码没有做任何事情；咱 们指定的闭包从未被调用。这个警告 提醒了我们为什么 ：迭代器适配器是懒惰的，我们需要在这里消费迭代器。
清单 13-14 中的代码未执行任何操作；我 们指定的闭包从未被调用。这一告警 提醒了我们原因 ：迭代器适配器是懒惰的，而 我们需要在这里消费迭代器。
为修正此 告警并消费迭代器，咱们将使用 `collect` 方法，在第 12 章的清单 12-1 中，咱们曾 对 `env::args` 用到 过该方法。此 方法会消费迭代器，并将 结果值收集到一个 集合数据类型中。
为了解决这一 告警并消费该 迭代器，咱们将使用 `collect` 方法，我们在 [清单 12-1 ](../io_project/accepting_cli_arguments.md#listing_12-1 ) 中 对 `env::args` 使 用过该方法。这个 方法会消费迭代器，并收集 结果值到 集合数据类型中。
下面清单 13-15 中，咱们把对从到 `map` 调用， 返回的迭代器遍历 的结果，收集 到一个矢量值中。这个矢量最终将包含原矢量中增加 `1` 后的每一项 。
在 下面清单 13-15 中，我们收集了遍历从调用 `map` 返回的迭代器的结果到一个矢量值中。这个矢量最终将包含原矢量值中的每个项目，且都增加 1 。
<a name="listing_13-15"></a>
文件名：`src/main.rs`
``` rust
@@ -163,24 +165,24 @@ warning: `iterator_demo` (bin "iterator_demo") generated 1 warning
assert_eq! ( v2 , vec! [ 2 , 3 , 4 ] ) ;
```
* ： 出新 迭代器，并随 后调用 `collect` 方法消费这个 新的迭代器并创建出 一个矢量值*
** 清单 13-15** 一个新的 迭代器，然 后调用
由于 `map` 取了 一个闭包，因此咱们便可指定出，咱们想要对各个条目执行 的任何操作。这是一 个很好的例子，说明 闭包如何让咱们在重用Iterator属性 提供的迭代行为的同时，定制一 些行为。
由于 `map` 取一个闭包，因此我们可以指定对每个项目想要 的任何操作。这是个很好的示例，展示了 闭包如何让咱们在重用 ` Iterator` 特质 提供的迭代行为的同时，自定义某 些行为。
咱们可将 多个调用，链接 到迭代器适配器，来以能读懂 方式执行复杂操作。但由于所有迭代器都是惰性 的，因此咱们必须调用一个 消费适配器方法， 调用 迭代器适配器的结果。
咱们可以链接 多个调用到迭代器适配器，以可读的 方式执行复杂操作。但由于所有迭代器都是懒 惰的，因此咱们必须调用消费适配器方法之一 ，来获取迭代器适配器（方法）调用 的结果。
## 使用 捕获其 环境的闭包
## 捕获环境的闭包
**Using Closures that Capture Their Environment **
许多迭代器适配器都会取闭包作为参数，且我们将作为参数指定给迭代器适配器的闭包，往往都将是一些会捕获其环境的闭包。
针对这一示例，我们将使用取一个闭包的 `filter` 方法。这个闭包获取一个迭代器中的项目并返回一个 `bool` 值。当闭包返回 `true` 时，值将包含在 `filter` 产出的迭代中。当闭包返回 `false` 时，值不会被包含。
许多迭代器适配器，都会取闭包作参数，且通常咱们指定给迭代器适配器的闭包，都将是捕获其环境的闭包 。
> **译注**：原文这里有拼写错误，"If the closure returns `true`, the value will be included in the iteration produced by `filter`." 译者已通过 [Spell problem in Ch13-2 #4705](https://github.com/rust-lang/book/issues/4705) 提交该问题 。
咱们将使用取闭包的 `filter` 方法，作为这方面的示例。闭包从其所在迭代器获取到一个条目，并返回一个 `bool` 。闭包返回 `true` 时，条目的值将被包含在由 `filter` 产生出的迭代中。在闭包返回 `false` 时，条目的值则不会被包含 。
下面清单 13-16 中，咱们使用带有捕获其环境中 `shoe_size` 变量闭包的 `filter` 方法，来迭代 `Shoe` 结构体实例的集合。他将返回仅限特定尺码的鞋子。
在下面清单 13-16 中，我们以一个闭包使用 `filter` ，会捕获其环境中的 `shoe_size` 变量，以遍历 `Shoe` 结构体实例的集合。他将仅返回指定尺码的鞋子 。
<a name="listing_13-16"></a>
文件名：`src/lib.rs`
``` rust
Hector PENG