翻譯來源

這篇文章的目的是為一些常見的iterator提供參考資料。並不能替代Iterator
API或者書中的Rust iterator核心概念 ，事實上這篇文章的內容來自以上兩種內容。

為了更好理解本篇文章內容，推薦讀者至少粗略瞭解Rust

如何編譯執行例子

git clone https://github.com/rustomax/rust-iterators.git
cd rust-iterators/
cargo run

程式碼中使用了nightly版本的特性，如果你的Rust 為statble版本，請註釋相應的程式碼區域。

0介紹

生活是重複的，其中的大部分事物都是成系列的。我們經常需要記錄(count)、列舉
(enumerate)、反覆申明(iterate)這些事物。在程式設計中，有多種方式產生重複事物(repetition)，其中最為人熟知的是C風格的for迴圈。

for ( x = 0; x < 10; ++x ) {
  // do something
}

雖然這種可行的方法足夠強大而且足夠靈活以適應多種情況，但它承擔著對應的bug份額，例如錯誤分號放置、無意中在迴圈內部修改變數。本著與其他語言特性的安全和一致的精神，Rust中沒有C風格的迴圈。 相反，Rust利用迭代器實現類似的目標（還有更多）。

1.基本Range

在Rust中迴圈一系列整數的最基本的方法是Range。Range由..標記產生，它生成步長為1的iterator 。

for i in 1..11 {
    print!("{} ", i);
}
// output: 1 2 3 4 5 6 7 8 9 10
 

上面的程式碼將列印從1到10的一系列數字，而不包括最後一個數字11.換句話說，..會產生一個iterator ，它包含左邊的數，排除在右邊的數。 為了得到一個包含兩端的範圍的iterator，你使用...符號。 包含兩端的範圍的iterator目前是一個不穩定的功能，需要nightly編譯器

#![feature(inclusive_range_syntax)]

for i in 1...10 {
  print!("{} ", i);
}
// output: 1 2 3 4 5 6 7 8 9 10

如果你不使用迴圈迭代器變數，你可以通過利用_來避免例項化它。 例如，下面的程式碼不需要例項化一個迴圈迭代器變數就可以輸出迭代器中元素的數量：

let mut n: i32 = 0;
for _ in 0..10 {
  n += 1;
}
println!("num = {}", n);
// output: num = 10

上面的例子是有些多餘，因為Rust中的迭代器有count()函式，它返回迭代器中元素的數量，而不需要在迴圈中對它們進行計數：

println!("num = {}", (0..10).count());
// output: num = 10

你會發現有經驗的Rust程式設計師能夠用非常簡潔的迭代器語言來表達，而不是採用的傳統迴圈程式碼行。 當我們談論介面卡(adaptor)，消費者(consumer)和將迭代器方法連結(chaining)到複雜的語句時，我們將覆蓋下面的一些模式。

2.深層發掘（Digging Deeper）

如果基本的增量順序Range 不能滿足你的需要，Rust中有很多方法來定製Range迭代器。 我們來看幾個常見的問題。

通常，Range遞增不是1，而是增加一個不同的數字。 這可以通過filter()方法來實現。 它應用一個閉包(closure)，它可以為迭代器的每個元素返回true或false，併產生一個只包含閉包返回true的元素的迭代器。

下面的迭代器將產生一個0到20之間的偶數序列。

for i in (0..21).filter(|x| (x % 2 == 0)) {
  print!("{} ", i);
}
// output: 0 2 4 6 8 10 12 14 16 18 20

因為filter()使用閉包，所以非常靈活，可以用來生成複雜迭代器。 例如，下面的迭代器產生0到20之間的一系列整數，它們除以2和3得到餘數：

for i in (0..21).filter(|x| (x % 2 == 0) && (x % 3 == 0)) {
  print!("{} ", i);
}
// output: 0 6 12 18

雖然預設範圍是遞增的，但是使用rev()方法可以很容易地將其反轉。

for i in (0..11).rev() {
  print!("{} ", i);
}
// output: 10 9 8 7 6 5 4 3 2 1 0

另一個常見的迭代器介面卡map()將閉包應用於每個元素，並返回結果迭代器。下面是一個迭代器的例子，它產生一個從1到10的數字的正方形序列：

for i in (1..11).map(|x| x * x) {
    print!("{} ", i);
}
// output: 1 4 9 16 25 36 49 64 81 100

fold()是一個非常強大的方法。 它返回一個特殊的“累加器”型別閉包的結果給迭代器的所有元素，得到一個單一的值。 下面的迭代器產生從1到5的數字的平方和。

#![feature(inclusive_range_syntax)]

let result = (1...5).fold(0, |acc, x| acc + x * x);
println!("result = {}", result);

// output: result = 55

也許理解這裡發生的最簡單的方法是以更程式化的方式重寫上面的例子：

#![feature(inclusive_range_syntax)]

let mut acc = 0;

for x in 1...5 {
  acc += x * x;
}

let result = acc;
println!("result = {}", result);

// output: result = 55

哇！fold()版本是不是更加簡潔和可讀？

3.陣列迭代（Iterating over Arrays）

與迭代Range類似，我們可以迭代一個數組。 這樣做的好處是陣列可以包含任意型別的值，而不僅僅是整數。 唯一的警告是該陣列不是一個迭代器。 我們需要使用iter()方法把它變成一個迭代器。

let cities = ["Toronto", "New York", "Melbourne"];

for city in cities.iter() {
  print!("{}, ", city);
}
// output: Toronto, New York, Melbourne,

4.組合迭代器介面卡（Combining Iterator Adaptors）

在前面的章節中，我們介紹了各種各樣的方法，可以讓你生成許多不同型別的迭代器，當你開始結合這些方法的時候，Rust表現十分突出。

如果你想要一個10到0之間以步長2Range呢？ 通過將一個特性和幾個方法組合到一個迭代器中可以很容易地完成這個任務：

#![feature(inclusive_range_syntax)]

for i in (0...10).rev().filter(|x| (x % 2 == 0)) {
  print!("{} ", i);
}
// output: 10 8 6 4 2 0

需要一個不連續的Range（基本上是兩個不相Range的組合）？ 您可以使用chain()方法組合多個範圍：

let c = (1..4).chain(6..9);

for i in c {
  print!("{} ", i);
}
// output: 1 2 3 6 7 8

你可以得到很有創意的組合的東西！ 下面是一個迭代器，結合了兩個範圍：第一個遞增和過濾，另一個 是遞減。 不知道這樣一個可憎的東西怎麼產生，但在這裡卻是實現！

let r = (1..20)
  .filter(|&x| x % 5 == 0)
  .chain((6..9).rev());

for i in r {
  print!("{} ", i);
}
// output: 5 10 15 8 7 6

請注意，在上面的例子中，Rust允許我們通過將複雜的迭代器語句拆分為多行來更好地表示覆雜的迭代器語句。

另一個方便的方法是zip()。 它有點類似於chain()，因為它將兩個迭代器合併為一個。 與chain()相比，zip()不產生連續的迭代器，而是產生元組(tuple)的迭代器：

let cities = ["Toronto", "New York", "Melbourne"];
let populations = [2_615_060, 8_550_405, ‎4_529_500];

let matrix = cities.iter().zip(populations.iter());

for (c, p) in matrix {
  println!("{:10}: population = {}", c, p);
}
// output:
// Toronto   : population = 2615060
// New York  : population = 8550405
// Melbourne : population = 4529500

5.字元Range（Ranges of Characters）

操作字串或文字的位元組數通常需要迭代字元Range的能力。 char_iter提供了方便的方法來產生這樣的範圍。 char_iter支援Unicode字元。

要使用char_iter，請在Cargo.toml中新增以下內容

[dependencies]
char-iter = "0.1"

接著通過char_iter::new()產生字元Range

extern crate char_iter;

for c in char_iter::new('Д', 'П') {
  print!("{} ", c);
}
// output: Д Е Ж З И Й К Л М Н О П

6.向量迭代（Iterating over Vectors）

向量是Rust的基本結構之一。 就其性質而言，它非常適合於表示一系列重複專案。 Rust中有許多語言工具允許使用向量作為迭代器，反之亦然。

在最簡單的情況下，類似於我們如何從陣列建立迭代器，我們可以使用iter()方法從向量建立迭代器。 事實上，這被認為是Rust在迭代向量中最習慣的方式。

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

for i in nums.iter() {
   print!("{} ", i);
}
// output: 1 2 3 4 5

事實上，上面的模式非常普遍，Rust的引用操作符＆為其提供了句法糖。

let nums = vec![1, 2, 3, 4, 5];
for i in &nums {
   print!("{} ", i);
}
// output: 1 2 3 4 5

注意上面的借用(borrow)是不可改變的。 換句話說，它們是隻讀的。 如果我們想要改變我們的向量，我們必須使用可變的借用＆mut。 例如，下面的程式碼將可變地迭代一個向量，使處理中的每個元素加倍。

let mut nums = vec![1, 2, 3, 4, 5];
for i in &mut nums {
    *i *= 2;
}
println!("{:?}", nums);

//output: [2, 4, 6, 8, 10]

然而，現在你是一個迭代忍者()，你不會使用上面的for迴圈語法。 你會用一個地map()來代替，對嗎？

let nums = vec![1, 2, 3, 4, 5];
let nums = nums.iter().map(|x| x * 2);
println!("{:?}", nums);

//output: [2, 4, 6, 8, 10]

輕微的離題。 如果我們想要使用可變的迭代器將元素新增到向量中，如下所示：

let mut nums = vec![1, 2, 3, 4, 5];
for i in &mut nums {
    nums.push(*i);
}
println!("{:?}", nums);

它不編譯，並丟擲錯誤資訊cannot borrow `nums` as mutable more than once at a time。 你看，我們的迭代器（在for迴圈中例項化）已經借用nums作為可變。 push表達試圖再次這樣做，這是禁止的。 這是在Rust中著名的安全機制。 如果我們可以將某個push入向量中，同時迭代它，則會導致迭代器失效，從而導致未定義的行為。 Rust可以在編譯時防止發生這種情況。 迭代器不僅強大，而且它們也是超級安全的。

現在，我們做相反的事情 : 從迭代器建立一個向量。 為了做到這一點，我們需要所謂的消費者。 消費者迫使懶惰的迭代器實際產生值。collect()是一個普通的消費者。 它從一個迭代器獲取值並將它們轉換為所需型別的集合。 下面我們將從1到10的一系列數字變換成一個向量i32：

let v = (1..11).collect::<Vec<i32>>();
println!("{:?}", v);
// output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

為了獲得向量的元素及其索引，可以使用enumerate()方法，該方法在每次迭代中返回一個包含索引和專案的元組：

let v = vec![1, 2, 3];
for (i, n) in v.iter().enumerate() {
    println!("v[{}] = {}", i, n);
}
// output:
// v[0] = 1
// v[1] = 2
// v[2] = 3

還有一些其他的功能，使向量上的迭代器特別有用。
min()和max()，例如返回Option，分別包含向量元素的最小值和最大值：

let v = vec![3, 5, 0, -2, 3, 4, 1];
let max = v.iter().max();
let min = v.iter().min();

println!("max = {:?}, min = {:?}", max, min);

// output: max = Some(5), min = Some(-2)

sum()返回迭代器中所有值的總和。 以下程式利用sum()方法來計算一個相當平庸的學生的平均成績：

let grades = vec![4, 5, 6, 9, 7, 4, 8];
let sum: i32 = grades.iter().sum();
let gpa = sum as f32 / grades.len() as f32;

println!("sum = {}, gpa = {:.2}", sum, gpa);

// output: sum = 43, gpa = 6.14

7.無限與超越(Infinity and Beyond)

到目前為止，我們已經處理了在某些有限範圍的值上執行的迭代器。 Rust以這種方式推廣迭代器，實際上可以建立一個無限範圍！ 讓我們考慮下面的例子：

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

(1..)定義了一個從1開始並且無限增量的Range。 實際上，這樣的程式編譯和執行，但最終崩潰的錯誤訊息：fatal runtime error: out of memory。 那麼，你可能會說這不是很實際。 事實上，無限範圍本身是無用的。 讓他們有用的是將他們與其他介面卡和消費者結合起來。

一個特別有用的模式涉及使用take()方法來限制迭代器返回的專案數量。 下面的迭代器將返回可以被5整除的整數的正方形序列中的前10個。

let v = (1..)
  .map(|x| x * x)
  .filter(|x| x % 5 == 0 )
  .take(10)
  .collect::<Vec<i32>>();

println!("{:?} ", v);

// output: [25, 100, 225, 400, 625, 900, 1225, 1600, 2025, 2500]

8.Itertools

itertools包含強大的附加迭代器介面卡。 以下是一些例子。

為了使用itertools，需要在Cargo.toml加入如下配置：

[dependencies]
itertools = "0.6"

請回憶我們如何使用filter()生成一個偶數範圍？ Itertools有一個方便的step()方法。

extern crate itertools;
use itertools::Itertools;

for i in (0..11).step(2) {
    print!("{} ", i);
}

//output: 0 2 4 6 8 10

unique()介面卡消除了迭代器的重複。 重複項不需要順序。

extern crate itertools;
use itertools::Itertools;

let data = vec![1, 4, 3, 1, 4, 2, 5];
let unique = data.iter().unique();

for d in unique {
  print!("{} ", d);
}

//output: 1 4 3 2 5

join()介面卡將迭代器元素組合為單個字串，元素之間有一個分隔符。

extern crate itertools;
use itertools::Itertools;

let creatures = vec!["banshee", "basilisk", "centaur"];
let list = creatures.iter().join(", ");
println!("In the enchanted forest, we found {}.", list);

// output: In the enchanted forest, we found banshee, basilisk, centaur.

sorted_by()介面卡將自定義排序順序應用於迭代器元素，返回排序後的向量。 根據2016年“世界幸福指數”，以下計劃將打印出前5名最幸福的國家。

extern crate itertools;
use itertools::Itertools;

let happiness_index = vec![ ("Austria", 12), ("Costa Rica", 14), ("Norway", 4),
  ("Australia", 9), ("Netherlands", 7), ("New Zealand", 8), ("United States", 13),
  ("Israel", 11), ("Denmark", 1), ("Finland", 5), ("Iceland", 3),
  ("Sweden", 10), ("Canada", 6), ("Puerto Rico", 15), ("Switzerland", 2) ];

let top_contries = happiness_index
  .into_iter()
  .sorted_by(|a, b| (&a.1).cmp(&b.1))
  .into_iter()
  .take(5);

for (country, rating) in top_contries {
  println!("# {}: {}", rating, country);
}

// output:
// # 1: Denmark
// # 2: Switzerland
// # 3: Iceland
// # 4: Norway
// # 5: Finland

9.定製迭代器（Creating Your Own Iterators）

Rust的優點在於，你可以使用通用語言工具來擴充套件它。 讓我們利用這個強大的力量，創造我們自己的迭代器！ 我們將構建一個非常簡單的迭代器，產生一系列由浮點數(f32，f32)組成的溫度(華氏，攝氏)對。 溫度使用公知的公式計算：°C =(°F-32)/ 1.8。

迭代器以一個結構體(struct)開始。 我們命名的結構體名稱也將是迭代器的名稱。 我們將呼叫FahrToCelc。 該結構體包含一些有用的資訊，這些資訊在隨後的迭代器呼叫之間保持不變。 我們將有兩個 f32 fields : 華氏溫度和增量步長：

struct FahrToCelc {
  fahr: f32,
  step: f32,
}

接下來，我們將建立一個的方法new()，它通過初始化迭代器的初始值以華氏溫度和增量步長進行初始化。 這個方法嚴格來說不是必須的，不是迭代器實現的一部分，但是我覺得它是一個很好的語法糖，可以提高程式的整體可讀性：

impl FahrToCelc {
  fn new(fahr: f32, step: f32) -> FahrToCelc {
    FahrToCelc { fahr: fahr, step: step }
  }
}

最後，我們通過為結構實現Iterator Trait來編寫迭代器的行為。 至少需要包含以下內容：

• 定義Item型別。 它描述了迭代器將產生什麼樣的東西。 如前所述，我們的迭代器產生由浮點數(f32，f32)元組表示的溫度對(華氏，攝氏)，所以我們的Item型別定義如下所示：

 type Item = (f32, f32);

• 函式next()實際上會生成下一個Item。 next()對self進行可變引用( mutable reference)，並返回一個封裝下一個值的Option。 我們必須返回一個選項而不是專案本身的原因是因為許多迭代器需要考慮它們已經達到序列結束的情況，在這種情況下它們返回None。 由於我們的迭代器生成一個無限序列，我們的next()方法將始終返回Option <Self :: Item>。 因此，我們的next()函式宣告如下所示：

fn next (&mut self) -> Option<Self::Item>

next()函式通常也會進行一些內部管理。 我們逐步增加華氏溫度fahr，以便在隨後的迭代中返回。 對內部欄位進行這些修改是我們需要將self的可變引用傳遞給next()作為引數的原因。
結合在一起，這裡是迭代器特徵的實現：

impl Iterator for FahrToCelc {
  type Item = (f32, f32);

  fn next (&mut self) -> Option<Self::Item> {
    let curr_fahr = self.fahr;
    let curr_celc = (self.fahr - 32.0) / 1.8;
    self.fahr = self.fahr + self.step;
    Some((curr_fahr, curr_celc))
  }
}

最終的完整程式如下：

struct FahrToCelc {
  fahr: f32,
  step: f32,
}

impl FahrToCelc {
  fn new(fahr: f32, step: f32) -> FahrToCelc {
    FahrToCelc { fahr: fahr, step: step }
  }
}

impl Iterator for FahrToCelc {
  type Item = (f32, f32);

  fn next (&mut self) -> Option<Self::Item> {
    let curr_fahr = self.fahr;
    let curr_celc = (self.fahr - 32.0) / 1.8;
    self.fahr = self.fahr + self.step;
    Some((curr_fahr, curr_celc))
  }
}

fn main() {
  // pass the starting temperature and step to the initializer function
  let ftc = FahrToCelc::new(0.0, 5.0);

  // produce the iterator table of first 5 values
  let temp_table = ftc.take(5);

  // print out the temperature table nicely
  for (f, c) in temp_table {
    println!("{:7.2} °F = {:7.2} °C", f, c);
  }
}

// output:
//  0.00 °F =  -17.78 °C
//  5.00 °F =  -15.00 °C
// 10.00 °F =  -12.22 °C
// 15.00 °F =   -9.44 °C
// 20.00 °F =   -6.67 °C