# 迭代器
> [iterators.md](https://github.com/rust-lang/rust/blob/master/src/doc/book/iterators.md)
commit 6ba952020fbc91bad64be1ea0650bfba52e6aab4
让我们讨论一下循环。
还记得Rust的`for`循环吗？这是一个例子：
~~~
for x in 0..10 {
println!("{}", x);
}
~~~
现在我们更加了解Rust了，我们可以谈谈这里的具体细节了。这个范围（`0..10`）是“迭代器”。我们可以重复调用迭代器的`.next()`方法，然后它会给我们一个数据序列。
就像这样：
~~~
let mut range = 0..10;
loop {
match range.next() {
Some(x) => {
println!("{}", x);
},
None => { break }
}
}
~~~
我们创建了一个`range`的可变绑定，它是我们的迭代器。我们接着`loop`，它包含一个`match`。`match`用来匹配`range.next()`的结果，它给我们迭代器的下一个值。`next`返回一个`Option<i32>`，在这个例子中，如果有值,它会返回`Some(i32)`然后当我们循环完毕,就会返回`None`。如果我们得到`Some(i32)`，我们就会打印它，如果我们得到`None`，我们`break`出循环。
这个代码例子基本上和我们的`loop`版本一样。`for`只是`loop`/`match`/`break`结构的简便写法。
然而，`for`循环并不是唯一使用迭代器的结构。编写你自己的迭代器涉及到实现`Iterator`特性。然而特性不是本章教程的涉及范围，不过Rust提供了一系列的有用的迭代器帮助我们完成各种任务。但首先注意下*范围* 的一些局限性。
*范围* 非常原始，我们通常可以用更好的替代方案。考虑下面的 Rust 反模式：用*范围* 来模拟 C-风格的`for`循环。比如你想遍历完 vector 的内容。你可能尝试这么写：
~~~
let nums = vec![1, 2, 3];
for i in 0..nums.len() {
println!("{}", nums[i]);
}
~~~
这严格的说比使用现成的迭代器还要糟。你可以直接在 vector 上遍历。所以这么写：
~~~
let nums = vec![1, 2, 3];
for num in &nums {
println!("{}", num);
}
~~~
这么写有两个原因。第一，它更明确的表明了我们的意图。我们迭代整个向量，而不是先迭代向量的索引，再按索引迭代向量。第二，这个版本也更有效率：第一个版本会进行额外的边界检查因为它使用了索引，`nums[i]`。因为我们利用迭代器获取每个向量元素的引用，第二个例子中并没有边界检查。这在迭代器中非常常见：我们可以忽略不必要的边界检查，不过仍然知道我们是安全的。
这里还有一个细节不是100%清楚的就是`println!`是如何工作的。`num`是`&i32`类型。也就是说，它是一个`i32`的引用，并不是`i32`本身。`println!`为我们处理了解引用，所以我们并没有看到它。下面的代码也能工作：
~~~
let nums = vec![1, 2, 3];
for num in &nums {
println!("{}", *num);
}
~~~
现在我们显式的解引用了`num`。为什么`&nums`会给我们一个引用呢？首先，因为我们显式的使用了`&`。再次，如果它给我们数据，我们就是它的所有者了，这会涉及到生成数据的拷贝然后返回给我们拷贝。通过引用，我们只是借用了一个数据的引用，所以仅仅是传递了一个引用，并不涉及数据的移动。
那么，既然现在我们已经明确了范围通常不是我们需要的，让我们来讨论下你需要什么。
这里涉及到大体上相关的3类事物：迭代器，*迭代适配器*（*iterator adapters*）和*消费者*（*consumers*）。下面是一些定义：
- *迭代器* 给你一个值的序列
- *迭代适配器* 操作迭代器，产生一个不同输出序列的新迭代器
- *消费者* 操作迭代器，产生最终值的集合
让我们先看看消费者，因为我们已经见过范围这个迭代器了。
### 消费者（Consumers）
*消费者* 操作一个迭代器，返回一些值或者几种类型的值。最常见的消费者是`collect()`。这个代码还不能编译，不过它表明了我们的意图：
~~~
let one_to_one_hundred = (1..101).collect();
~~~
如你所见，我们在迭代器上调用了`collect()`。`collect()`从迭代器中取得尽可能多的值，然后返回结果的集合。那么为什么这不能编译呢？因为Rust不能确定你想收集什么类型的值，所以你需要让它知道。下面是一个可以编译的版本：
~~~
let one_to_one_hundred = (1..101).collect::<Vec<i32>>();
~~~
如果你还记得，`::<>`语法允许我们给出一个类型提示，所以我们可以告诉编译器我们需要一个整型的向量。但是你并不总是需要提供完整的类型。使用`_`可以让你提供一个部分的提示：
~~~
let one_to_one_hundred = (1..101).collect::<Vec<_>>();
~~~
这是指“请把值收集到`Vec<T>`，不过自行推断`T`类型”。为此`_`有时被称为“类型占位符”。
`collect()`是最常见的消费者，不过这还有其它的消费者。`find()`就是一个：
~~~
let greater_than_forty_two = (0..100)
.find(|x| *x > 42);
match greater_than_forty_two {
Some(_) => println!("Found a match!"),
None => println!("No match found :("),
}
~~~
`find`接收一个闭包，然后处理迭代器中每个元素的引用。如果这个元素是我们要找的，那么这个闭包返回`true`，如果不是就返回`false`。因为我们可能不能找到任何元素，所以`find`返回`Option`而不是元素本身。
另一个重要的消费者是`fold`。他看起来像这样：
~~~
let sum = (1..4).fold(0, |sum, x| sum + x);
~~~
`fold()`看起来像这样：`fold(base, |accumulator, element| ...)`。它需要两个参数：第一个参数叫做*基数*（*base*）。第二个是一个闭包，它自己也需要两个参数：第一个叫做*累计数*（*accumulator*），第二个叫*元素*（*element*）。每次迭代，这个闭包都会被调用，返回值是下一次迭代的累计数。在我们的第一次迭代，基数是累计数。
好吧，这有点混乱。让我们检查一下这个迭代器中所有这些值：
| 基数 | 累计数 | 元素 | 闭包结果 |
|-----|-----|-----|-----|
| 0 | 0 | 1 | 1 |
| 0 | 1 | 2 | 3 |
| 0 | 3 | 3 | 6 |
我们可以使用这些参数调用`fold()`：
~~~
# (1..4)
.fold(0, |sum, x| sum + x);
~~~
那么，`0`是我们的基数，`sum`是累计数，`x`是元素。在第一次迭代，我们设置`sum`为`0`，然后`x`是`nums`的第一个元素，`1`。我们接着把`sum`和`x`相加，得到`0 + 1 = 1`。在我们第二次迭代，`sum`成为我们的累计值，元素是数组的第二个值，`2`，`1 + 2 = 3`，然后它就是最后一次迭代的累计数。在这次迭代中，`x`是最后的元素，`3`，那么`3 + 3 = 6`，就是我们和的最终值。`1 + 2 + 3 = 6`，这就是我们的结果。
（口哨）。最开始你见到`fold`的时候可能觉得有点奇怪，不过一旦你习惯了它，你就会在到处都用它。任何时候你有一个列表，然后你需要一个单一的结果，`fold`就是合适的。
消费者很重要还因为另一个我们没有讨论到的迭代器的属性：惰性。让我们更多的讨论一下迭代器，你就知道为什么消费者重要了。
### 迭代器（Iterators）
正如我们之前说的，迭代器是一个我们可以重复调用它的`.next()`方法，然后它会给我们一个数据序列的结构。因为你需要调用函数，这意味着迭代器是*惰性的*（*lazy *）并且不需要预先生成所有的值。例如，下面的代码并没有真正的生成`1-99`这些数，而是创建了一个值来代表这个序列：
~~~
let nums = 1..100;
~~~
因为我们没有用范围做任何事，它并未生成序列。让我们加上消费者：
~~~
let nums = (1..100).collect::<Vec<i32>>();
~~~
现在，`collect()`会要求范围生成一些值，接着它会开始产生序列。
范围是你会见到的两个基本迭代器之一。另一个是`iter()`。`iter()`可以把一个向量转换为一个简单的按顺序给出每个值的迭代器：
~~~
let nums = vec![1, 2, 3];
for num in nums.iter() {
println!("{}", num);
}
~~~
这两个基本迭代器应该能胜任你的工作。还有一些高级迭代器，包括一个是无限的。
关于迭代器的介绍足够了。迭代适配器是关于迭代器最后一个要介绍的内容了。让我们开始吧！
### 迭代适配器（Iterator adapters）
*迭代适配器*（*Iterator adapters*）获取一个迭代器然后按某种方法修改它，并产生一个新的迭代器。最简单的是一个是`map`：
~~~
(1..100).map(|x| x + 1);
~~~
在其他迭代器上调用`map`，然后产生一个新的迭代器，它的每个元素引用被调用了作为参数的闭包。所以它会给我们`2-100`这些数字。好吧，看起来是这样。如果你编译这个例子，你会得到一个警告：
~~~
warning: unused result which must be used: iterator adaptors are lazy and
do nothing unless consumed, #[warn(unused_must_use)] on by default
(1..100).map(|x| x + 1);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~
又是惰性！那个闭包永远也不会执行。这个例子也不会打印任何数字：
~~~
(1..100).map(|x| println!("{}", x));
~~~
如果你尝试在一个迭代器上执行带有副作用的闭包，不如直接使用`for`。
有大量有趣的迭代适配器。`take(n)`会返回一个源迭代器下`n`个元素的新迭代器，注意这对源迭代器没有副作用。让我们试试我们之前的无限迭代器，`count()`：
~~~
for i in (1..).take(5) {
println!("{}", i);
}
~~~
这会打印：
~~~
1
2
3
4
5
~~~
`filter()`是一个带有一个闭包参数的适配器。这个闭包返回`true`或`false`。`filter()`返回的新迭代器只包含闭包返回`true`的元素：
~~~
for i in (1..100).filter(|&x| x % 2 == 0) {
println!("{}", i);
}
~~~
这会打印出1到100之间所有的偶数。（注意因为`filter`并不消费它迭代的元素，它传递每个元素的引用，所以过滤器使用`&x`来提取其中的整型数据。）
你可以链式的调用所有三种结构：以一个迭代器开始，适配几次，然后处理结果。看看下面的：
~~~
(1..)
.filter(|&x| x % 2 == 0)
.filter(|&x| x % 3 == 0)
.take(5)
.collect::<Vec<i32>>();
~~~
这会给你一个包含`6`，`12`，`18`，`24`和`30`的向量。
这只是一个迭代器、迭代适配器和消费者如何帮助你的小尝试。有很多非常实用的迭代器，当然你也可以编写你自己的迭代器。迭代器提供了一个安全、高效的处理所有类型列表的方法。最开始它们显得比较不寻常，不过如果你玩转了它们，你就会上瘾的。关于不同迭代器和消费者的列表，查看[迭代器模块文档](http://doc.rust-lang.org/std/iter/)。
- 前言
- 贡献者
- 1.介绍
- 2.准备
- 3.学习 Rust
- 3.1.猜猜看
- 3.2.哲学家就餐问题
- 3.3.其它语言中的 Rust
- 4.语法和语义
- 4.1.变量绑定
- 4.2.函数
- 4.3.原生类型
- 4.4.注释
- 4.5.If语句
- 4.6.循环
- 4.7.所有权
- 4.8.引用和借用
- 4.9.生命周期
- 4.10.可变性
- 4.11.结构体
- 4.12.枚举
- 4.13.匹配
- 4.14.模式
- 4.15.方法语法
- 4.16.Vectors
- 4.17.字符串
- 4.18.泛型
- 4.19.Traits
- 4.20.Drop
- 4.21.if let
- 4.22.trait 对象
- 4.23.闭包
- 4.24.通用函数调用语法
- 4.25.crate 和模块
- 4.26.const和static
- 4.27.属性
- 4.28.type别名
- 4.29.类型转换
- 4.30.关联类型
- 4.31.不定长类型
- 4.32.运算符和重载
- 4.33.Deref强制多态
- 4.34.宏
- 4.35.裸指针
- 4.36.不安全代码
- 5.高效 Rust
- 5.1.栈和堆
- 5.2.测试
- 5.3.条件编译
- 5.4.文档
- 5.5.迭代器
- 5.6.并发
- 5.7.错误处理
- 5.8.选择你的保证
- 5.9.外部函数接口
- 5.10.Borrow 和 AsRef
- 5.11.发布途径
- 5.12.不使用标准库
- 6.Rust 开发版
- 6.1.编译器插件
- 6.2.内联汇编
- 6.4.固有功能
- 6.5.语言项
- 6.6.链接进阶
- 6.7.基准测试
- 6.8.装箱语法和模式
- 6.9.切片模式
- 6.10.关联常量
- 6.11.自定义内存分配器
- 7.词汇表
- 8.语法索引
- 9.参考文献
- 附录：名词中英文对照