Iterators

Iterator trait 用来对集合（collection）类型（比如数组）实现迭代器。

这个 trait 只需定义一个返回 next（下一个）元素的方法，这可手动在 impl 代码块 中定义，或者自动定义（比如在数组或区间中）。

为方便起见，for 结构会使用 .into_iterator() 方法将一些集合类型 转换为迭代器。

下面例子展示了如何使用 Iterator trait 的方法，更多可用的方法可以看这里。

1. struct Fibonacci {
2. curr: u32,
3. next: u32,
4. }

6. // 为 `Fibonacci`（斐波那契）实现 `Iterator`。
7. // `Iterator` trait 只需定义一个能返回 `next`（下一个）元素的方法。
8. impl Iterator for Fibonacci {
9. type Item = u32;

11. // 我们在这里使用 `.curr` 和 `.next` 来定义数列（sequence）。
12. // 返回类型为 `Option<T>`：
13. //     * 当 `Iterator` 结束时，返回 `None`。
14. //     * 其他情况，返回被 `Some` 包裹（wrap）的下一个值。
15. fn next(&mut self) -> Option<u32> {
16. let new_next = self.curr + self.next;

18. self.curr = self.next;
19. self.next = new_next;

21. // 既然斐波那契数列不存在终点，那么 `Iterator` 将不可能
22. // 返回 `None`，而总是返回 `Some`。
23. Some(self.curr)
24. }
25. }

27. // 返回一个斐波那契数列生成器
28. fn fibonacci() -> Fibonacci {
29. Fibonacci { curr: 1, next: 1 }
30. }

32. fn main() {
33. // `0..3` 是一个 `Iterator`，会产生：0、1 和 2。
34. let mut sequence = 0..3;

36. println!("Four consecutive `next` calls on 0..3");
37. println!("> {:?}", sequence.next());
38. println!("> {:?}", sequence.next());
39. println!("> {:?}", sequence.next());
40. println!("> {:?}", sequence.next());

42. // `for` 遍历 `Iterator` 直到返回 `None`，
43. // 并且每个 `Some` 值都被解包（unwrap），然后绑定给一个变量（这里是 `i`）。       println!("Iterate through 0..3 using `for`");
44. for i in 0..3 {
45. println!("> {}", i);
46. }

48. // `take(n)` 方法提取 `Iterator` 的前 `n` 项。
49. println!("The first four terms of the Fibonacci sequence are: ");
50. for i in fibonacci().take(4) {
51. println!("> {}", i);
52. }

54. // `skip(n)` 方法移除前 `n` 项，从而缩短了 `Iterator` 。
55. println!("The next four terms of the Fibonacci sequence are: ");
56. for i in fibonacci().skip(4).take(4) {
57. println!("> {}", i);
58. }

60. let array = [1u32, 3, 3, 7];

62. // `iter` 方法对数组/slice 产生一个 `Iterator`。
63. println!("Iterate the following array {:?}", &array);
64. for i in array.iter() {
65. println!("> {}", i);
66. }
67. }