Iterator （迭代器）

Iterator 是rust标准库中定义的一个trait，通常称之为“迭代器”。任何实现了该trait 的结构体，都可以用 for in 的方式进行迭代化数据访问。Iterator trait 中有两个关键的定义，其一是 type Item，表示该迭代器返回的数据类型；其二是 next方法，即迭代方法（通过循序调用next方法，遍历集合中的数据）：

pub trait Iterator {
    /// The type of the elements being iterated over.
    type Item;
   /// Advances the iterator and returns the next value.
   /// Returns None when iteration is finished. Individual iterator implementations may choose to resume iteration, and so calling next() again may 
   /// or may not eventually start returning Some(Item) again at some point.
    fn next(&mut self) -> Option<Self::Item>;

  ... // 其他对集合操作的函数接口
}

 作为示例，我们可以写一个自己的简易迭代器：

struct Revolver {
    bullets: u16,
}

impl Revolver {
    fn new() -> Self {
        Revolver { bullets: 6 }
    }
    fn reload(&mut self) {
        self.bullets = 6;
    }
}

impl Iterator for Revolver {
    type Item = String;

    fn next(&mut self) -> Option<Self::Item> {
        if self.bullets > 0 {
            self.bullets -= 1;
            Some("Bang!".to_string())
        } else {
            None
        }
    }
}

#[test]
fn fire_all_bullets() {
     let  revolver = Revolver::new();
     for fired in revolver {
          println!("{}", fired);
     }
}

见代码片段，我们实现了一把左轮手枪，默认填6发子弹； 用for in 测试连续射击（fire_all_bullets），执行效果：

事实上，fire_all_bullets还有一个更直白的写法：

#[test]
fn fire_all_bullets() {
        let mut revolver = Revolver::new();
        loop {
            // 扣动扳机
            let fired = revolver.next();

            match fired {
                Some(bullet) => {
                    // 子弹发射
                    println!("{}", bullet)
                }
                // 没有子弹了，射击结束
                None => break,
            }
        }
}

上述代码和用for in 实现效果一样：Bang！Bang！Bang！Bang！Bang！Bang！

注意：当使用next() 手动遍历时，迭代器变量要设置为可变，这是因为迭代过程中会修改迭代器内部的数据！

事实上，loop展开的迭代器调用模式，才是迭代器真实执行的模型；for in 可以看做是编译器的语法糖，在编译期间将for in 迭代器展开为上述loop 的模型；只不过处理过程中，还会涉及一些数据克隆，引用转换，可变引用转换等，以方便使用；前一个测试中，for in 的revolver 没有加mut 也可以执行，这是因为for in 展开时，自己做了一次转换！

let  arr = vec![1, 2, 3, 4, 5];
for i in arr {
       println!("{}", i); 
}

按第二章的理解，for in 可以 直接作用于Vec，那么Vec应该实现了 Iterator？即Vec本身也是迭代器？

查看Vec实现并未发行Vec 实现了Iterator，相反它实现了IntoIterator 这个 trait。

功能如其名，IntoIterator 这个特性就是将实现了这个trait的数据转化为一个迭代器。

pub trait IntoIterator {
    /// The type of the elements being iterated over.
    type Item;

    /// Which kind of iterator are we turning this into?
    type IntoIter: Iterator<Item = Self::Item>;

    /// Creates an iterator from a value.
    fn into_iter(self) -> Self::IntoIter;
}

该trait主要包括三个成员： Item指定迭代器返回的元素；IntoIter 指定迭代器类型； into_iter实现由当前数据类型转化为指定迭代器的方法！

下面，我们用一个实例来演示一下IntoIterator 及Iterator 的关系和使用。

实战

考虑这样一个需求：对一个字符串，以空格为分割的方式，遍历获取每个单词。

直观的，要实现对一个字符串按空格进行逐个单词的迭代分割，我们需要引入一个位置标记（position），记录当前已经完成了单词分割的位置；当下一次请求单词时，从剩余的内容中找到下一个空格（或者直到内容末尾），将这部分内容作为分割的单词返回；同时，更新位置标记到当前返回的位置；最后，当位置标记到达原始字符串末尾时，处理完成，后续请求返回为None。

按照上面的思路，给出编码如下：

首先，自定义字符串数据结构：

// 定义MyString结构体
struct MyString {
    content: String,
}

通常，我们需要对现有数据进行额外处理时，为了不破坏原有的数据结构和实现，通过wapper包装是一个不错的选择。

其次，定义MyString的迭代器数据结构（根据上面的分析，需要一个位置标记来记录处理过程）：

// 定义MyStringIterator结构体
struct MyStringIterator {
    content: String,
    position: usize,
}

 第三，为MyStringIterator 实现Iterator特性，使之成为迭代器：

impl Iterator for MyStringIterator {
    type Item = String;

    fn next(&mut self) -> Option<Self::Item> {
        let refx = self.content.as_str();
        let bytes = refx.as_bytes();
        while self.position < refx.len() && bytes[self.position] == b' ' {
            self.position += 1;
        }

        if self.position < refx.len() {
            let rest = &refx[self.position..];
            let idx = rest.find(' ').unwrap_or(rest.len());
            let result = rest[0..idx].to_string();
            self.position += idx;
            Some(result)
        } else {
            None
        }
    }
}

这里，我们指定返回迭代的元素为String，即每个单词以String类型返回；next实现中，会自动跳过连续的空格，通过 &str.find接口找到下一个空格的位置（如果找不到，则直到末尾），并进行字符切片截取，再转化为Some(String)返回。

第四，为MyString 实现IntoIterator 特性，使其可以转换为迭代器，方便对内容进行迭代处理：

impl IntoIterator for MyString {
    type Item = String;
    type IntoIter = MyStringIterator;

    fn into_iter(self) -> Self::IntoIter {
        MyStringIterator {
            content: self.content,
            position: 0,
        }
    }
}

需要注意的是，实现IntoIterator时，需要指定元素类型和迭代器类型，并且所指定的元素类型和迭代器要求的元素类型相匹配。

into_inter中，接受的self 是MyString的实例，并且获得其所有权；同时，将MyString中content变量绑定到 迭代器的content上；初始化位置为0.

第五， 测试应用

 #[test]
    fn test_my_string_iterator() {
        let my_string = MyString {
            content: "My name is LiLei".to_string(),
        };
        let mut iter = my_string.into_iter();
        assert_eq!("My", iter.next().unwrap());
        assert_eq!("name", iter.next().unwrap());
        assert_eq!("is", iter.next().unwrap());
        assert_eq!("LiLei", iter.next().unwrap());

        let nstr = MyString {
            content: "What's your name?".to_string(),
        };
        for word in nstr {
            println!("{}", word);
        }
    }

执行效果：

bingo， 测试通过。手动迭代assert，for 循环打印符合预期按空格分割的单词进行迭代输出。

再说for in Vec

前面说到了 Vec并没有实现Iterator，那么Vec在for in 结构里是怎么执行的呢？

前面也说到，for in 结构在rust 中是一种语法糖，它自己会进行类型推导：for in 结构后变量是迭代器时，对迭代器进行循环展开；当for in 结构后的变量非迭代器时，编译器会推断其必须可以进行迭代器转换，即它必须有一个 IntoIterator 实现，并尝试调用其into_iter方法获取迭代器（如果没有实现则会报错）。

所以，开始示例的for in 直接作用于数组：

let  arr = vec![1, 2, 3, 4, 5];
for i in arr {
       println!("{}", i); 
}

等效于：

let  arr = vec![1, 2, 3, 4, 5];
for i in arr.into_iter {
       println!("{}", i); 
}

值得注意的是：

into_iter 进行迭代器转换时，会移走原始数据的所有权，导致原始数据不再可用！

如下测试代码：

#[test]
fn test_iter_vec() {
        let values = vec![1, 2, 3];
        for v in values {
            println!("{}", v)
        }
        println!("{:?}", values);
}

运行代码会报错：

错误提示说得明白，values 在再调用into_iter() 时被移交了所有权！

iter, iter_mut

在实际开发过程中，迭代器在数据处理上提供了很大的便利性；但是into_iter会拿走所有权会限制该模式在很多场景的使用。因此，很多数据类型在实现原始数据到迭代器的转化时，还提供了其他的转化方式。比如Vec还提供了 iter() 返回一个以不可变借用的方式遍历原数据的迭代器；iter_mut() 返回一个以可变借用的方式遍历原数据的迭代器。

以下是into_iter()，iter()， iter_mut()的一个对比测试， 大家可以实际跑一下，理解输出：

#[test]
fn test_iter_vec() {
        let values = vec![1, 2, 3];
        for v in values.into_iter() {
            println!("{}", v)
        }
        // 下面的代码将报错，因为 values 的所有权在上面 `for` 循环中已经被转移走
        // println!("{:?}",values);

        let values = vec![1, 2, 3];
        for v in values.iter() {
            println!("{}", v)
        }
        // 不会报错，因为 values_iter 只是借用了 values 中的元素
        println!("{:?}", values);

        let mut values = vec![1, 2, 3];
        for v in values.iter_mut() {
            *v = *v * 2;
        }
        // 输出[0, 4, 6]
        println!("{:?}", values);
}

注意：iter，iter_mut 不是 IntoIterator 的标准接口，用在for循环中时，必须显示调用！

当然，你也可以定义自己的转化函数，定义对原始数据的处理方式；但为了增加代码可读性，强烈建议遵循rust社区的一些通用编程实践！

最后

迭代器 Iterator中还有很多实用接口，比如map()，filter()， zip(),  count()等等。熟练掌握这些接口的功能和使用方法，能够让你在数据处理时更加游刃有余。这部分内容，就留给大家自行学习补充吧。