离线下载
PDF版 ePub版

极客学院团队出品 · 更新于 2018-10-23 17:00:35

迭代器

下面我们来探讨一下循环问题。

还记得 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 }
    }
}

我们针对范围给出一个可变的绑定,这就是迭代器。然后用一个内在的 match 进行 loop 。用这个 match 操作 range.next() 的结果,这就给出了到迭代器的下一个值的一个引用。next 返回一个 Option,在这种情况下,一旦循环运行完毕,我们会得到一个值: Some(i32) 或者 None。如果我们得到 Some(i32),就打印出来,如果我们得到 None,就跳出循环。

这个代码示例和我们的 for 循环版本基本上是一样的。for 循环仅仅是编写loop/match/break 构造的一个方便的方式。

然而,for 循环不是唯一使用迭代器的情况。编写自己的迭代器包括实现迭代器的特征。虽然这种操作不是在本指南的范围之内,Rust 提供了许多有用的迭代器来完成各种任务。在我们谈论这些之前,我们应该谈论一下 Rust 反模式。这就是范围的使用方式。

是的,我们刚刚谈到范围很有用。但范围也很原始。例如,如果你需要遍历一个 vector 的内容,你可能会这样写:

let nums = vec![1, 2, 3];

for num in &nums {
    println!("{}", num);
}

这比使用一个真正的迭代器严格的多。你可以直接对 vector 进行迭代,像下面写的这样:

let nums = vec![1, 2, 3];

for num in &nums {
    println!("{}", num);
}

这样做有两个原因。首先,这可以更直接的表达我们的意思。我们遍历整个 vector,而不是遍历索引,然后通过索引访问 vector。第二,这个版本是更高效的:第一个版本将有额外的边界检查,因为它使用了索引、nums[i]。但是因为我们使用迭代器依次针对 vector 的每个元素产生一个引用,在第二个示例中不涉及边界检查。这对于迭代器是很常见的:我们可以忽略不必要的检查范围,但仍知道我们是安全的。

关于 println! 怎样工作,这里还有一个细节不是 100% 的清楚。num 实际上是 &i32 类型的数字。也就是说,它是对 i32 的一个引用,而不是本身就是 i32println! 为我们处理非关联化的事物,所以我们不能看到它的细节。下面这段代码同样工作正常:

let nums = vec![1, 2, 3];

for num in &nums {
    println!("{}", *num);
}

现在我们来明确非关联化 num。为什么 &num 可以给我们引用?首先,因为我们明确地使用 & 调用。其次,如果给我们数据本身,我们必须是它的拥有者,它将生成一个数据的副本,并将副本给我们。与引用相比,我们只是借用了引用数据,所以它只是传递一个引用,而不需要做移动。

所以,既然我们已经认定范围往往不是你想要的,让我们来谈谈你想要的东西。

这里主要有3个类,它们是彼此相关的事物:迭代器(iterators),迭代器适配器(iterator adapters),和消费者(consumers)。下面给出一些定义:

  • 迭代器给出序列值。
  • 迭代器适配器使用一个迭代器,产生一个新的迭代器,它拥有不同的输出序列。
  • 消费者使用一个迭代器,产生一些值最后的设置。

首先让我们来谈谈消费者,因为你已经看到一个迭代器。

消费者

consumer 操作一个迭代器,返回某些类型的值。最常见的 consumer 是 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是什么。”因为这个原因 _ 有时被称为一种“占位符”。

collect() 是最常见的 consumer,但也存在其他的消费者。find()就是其中之一:

let greater_than_forty_two = (0..100)
                            .find(|x| *x > 42);

match greater_than_forty_two {
    Some(_) => println!("We got some numbers!"),
    None => println!("No numbers found :("),
}

find 消耗一个闭包,针对迭代器的每个元素的引用操作。如果元素是我们要找的元素,这个闭包返回 true,否则返回 false。因为我们可能找不到一个匹配的元素,find 会返回一个 Option 而不是元素本身。

另一个重要的消费者是 fold。下面就是 fold 的示例:

let sum = (1..4).fold(0, |sum, x| sum + x);

fold() 是一个消费者,语法:fold(base, |accumulator, element| ...)。它需要两个参数:第一个是一个称为 的元素 。第二个是一个闭包,本身有两个参数:第一个被称为累加器,第二个是一个元素。在每次迭代中,调用闭包,结果是在下一次迭代中累加器的值。在第一次迭代中,base 是累加器的值。

好吧,这有点令人困惑。让我们看看在这个迭代器中所有事物的值:

累加器 元素 闭包结果
0 0 1 1
0 1 2 3
0 3 3 6

我们使用这些参数来调用 fold() 函数:

.fold(0, |sum, x| sum + x);

所以,0 是基,sum 是累加器,x 是我们的元素。在第一次迭代中,我们将 sum 设置为 0xnums 的第一个元素 1。然后将 sumx 相加,即 0 + 1 = 1。第二次迭代中,和值成为我们的累加器 sum,元素是数组的第二个元素 2,相加,即 1 + 2 = 3 ,这样就得到了最后一次迭代的累加器的值。在这次迭代中,x 是最后一个元素 3 ,相加,即 3 + 3 = 6,这就是求和最后的结果。1 + 2 + 3 = 6,这就是我们最后得到的结果。

对于 fold 如果你刚开始接触它,可能会觉得这种语法有点奇怪,但一旦开始使用它,您会发现它的使用范围很广,几乎到处都可以使用。任何时候,如果你有一系列的事物,而你想要一个单一的结果,fold 都是最适当的。

由于迭代器存在另一个我们还没有谈到属性:懒惰,消费者就变得尤为重要。让我们多谈论一些关于迭代器的问题,你就会明白消费者为什么如此重要。

迭代器

正如之前说过的,我们可以使用 .next() 方法反复调用一个迭代器,它给出了一个事情的序列。因为你需要调用这个方法,这意味着迭代器可以偷懒,而不是预先生成的所有值。例如,在这段代码中,实际上并没有生成 1-100的数字,它仅仅代表了一个序列,而不是产生一个值:

let nums = 1..100;

因为我们没有针对范围做任何事情,它不会生成序列。下面让我们加入消费者:

let nums = (1..100).collect::<Vec<i32>>();

消费者 collect() 要求范围给它一些数字,这样它才会做生成序列的工作。

您将看到范围是两个基本的迭代器之一。另一种是 iter()iter() 可以把一个 vector 变成一个简单的迭代器,反过来这个迭代器给出每个元素:

let nums = vec![1, 2, 3];

for num in nums.iter() {
    println!("{}", num);
}

这两种基本迭代器应该能很好地为你服务。有一些更高级的迭代器,包括那些不限范围的。

这里谈论到的迭代器已经足够你使用。迭代器适配器是我们需要谈论的关于迭代器最后的概念。

迭代器适配器

迭代器适配器获得一个迭代器,以某种方式对其进行修改,产生一个新的迭代器。最简单的一个叫做 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 个元素的基础上返回一个新的迭代器。注意,这个对于原迭代器没有副作用。让我们使用一下之前提到的无限迭代器:

for i in (1..).step_by(5).take(5) {
    println!("{}", i);
}

这将打印出

1
6
11
16
21

filter() 是一个以一个闭包作为参数的适配器。这个闭包返回 true 或者 false。新的迭代器 filter() 产生唯一的元素,闭包返回true:

for i in (1..100).filter(|&x| x % 2 == 0) {
    println!("{}", i);
}

这将打印 1 到 100 之间的所有的偶数。(注意:因为 filter 不消耗将遍历的元素,它只是传递每一个元素的引用,从而可以使用 &x 模式过滤谓词来提取整数本身。)

现在你可以将三件事放在一起考虑:首先是一个迭代器,经过几次调整,然后消耗这个结果。检查一下:

(1..1000)
    .filter(|&x| x % 2 == 0)
    .filter(|&x| x % 3 == 0)
    .take(5)
    .collect::<Vec<i32>>();

这将给你一个包含 6、12、18、24 和 30 的向量。

这只是一个关于迭代器,迭代器适配器,和消费者的小的尝试。有很多非常有用的迭代器,您也可以编写您自己的迭代器。迭代器提供一个安全、有效的方式来操作各种列表。起初你会觉得它们有点不同寻常,但一旦你开始使用它们,你就会迷上它们。关于迭代器和消费者的不同点的完整列表,你可以查阅迭代器模块文档。

上一篇: 文档 下一篇: 并发性