rust学习-迭代器

迭代器的实现方式提供了对多种不同的序列使用相同逻辑的灵活性
没有迭代器时只能用索引，迭代器处理了所有这些逻辑，减少了重复代码，消除了潜在的混乱

示例

fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    // 无需使 v1_iter 可变，因为 for 循环会获取 v1_iter 的所有权并在后台使 v1_iter 可变
    for val in v1_iter {
        println!("Got: {}", val);
    }
}

原理

迭代器都实现了一个叫做 Iterator 的定义于标准库的 trait

pub trait Iterator {
    // type Item 和 Self::Item 定义了 trait 的 关联类型，associated type
    // 实现 Iterator trait 要求同时定义一个 Item 类型
    // 这个 Item 类型被用作 next 方法的返回值类型
    type Item;

    // next 一次返回迭代器中的一个项，封装在 Some 中
    // 当迭代器结束时，它返回 None
    fn next(&mut self) -> Option;

    // 此处省略了方法的默认实现
}

使用iter执行一个个的遍历

#[test]
fn iterator_demonstration() {
    let v1 = vec![1, 2, 3];
    // v1_iter 可变
    // 在迭代器上调用 next 方法改变了迭代器中用来记录序列位置的状态
    // 从 next 调用中得到的值是 vector 的不可变引用
    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

iter：生成一个不可变引用的迭代器
into_iter：获取 v1 所有权并返回拥有所有权的迭代器
iter_mut：迭代可变引用

消费适配器

调用它们会消耗迭代器
比如sum：获取迭代器的所有权并反复调用 next 来遍历迭代器，因而会消费迭代器。当其遍历每一个项时，它将每一个项加总到一个总和并在迭代完成时返回总和

#[test]
fn iterator_sum() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();
    
    // 调用 sum 之后不再允许使用 v1_iter 因为调用 sum 时它会获取迭代器的所有权
    let total: i32 = v1_iter.sum();
    assert_eq!(total, 6);
}

迭代器适配器

将当前迭代器变为不同类型的迭代器。
可以链式调用多个迭代器适配器。
因为所有迭代器都惰性，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果

使用闭包自定义行为同时，复用 Iterator trait 提供的迭代行为

let v1: Vec = vec![1, 2, 3];
// 调用 map 方法创建一个新迭代器，调用 collect 方法消费新迭代器并创建一个 vector
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
assert_eq!(v2, vec![2, 3, 4]);

// 编译如下代码将会warn，因为惰性迭代器没人使用，需要像上述那样，用collect触发下使用
// v1.iter().map(|x| x + 1);

使用闭包获取环境

使用 filter 迭代器适配器和捕获环境的闭包

迭代器的 filter 方法获取一个使用迭代器的每一个项并返回布尔值的闭包。如果闭包返回 true，其值将会包含在 filter 提供的新迭代器中。
如果闭包返回 false，其值不会包含在结果迭代器中

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_my_size(shoes: Vec, shoe_size: u32) -> Vec {
    // into_iter：获取一个vector 的所有权
    shoes.into_iter()
        // shoe_size 是环境，函数做不到，但是闭包可以做到
        // filter 将这个迭代器适配成一个只含有那些闭包返回 true 的元素的新迭代器
        .filter(|s| s.size == shoe_size)
        // 消费迭代器
        .collect()
}

#[test]
fn filters_by_size() {
    let shoes = vec![
        Shoe { size: 10, style: String::from("sneaker") },
        Shoe { size: 13, style: String::from("sandal") },
        Shoe { size: 10, style: String::from("boot") },
    ];

    let in_my_size = shoes_in_my_size(shoes, 10);

    assert_eq!(
        in_my_size,
        vec![
            Shoe { size: 10, style: String::from("sneaker") },
            Shoe { size: 10, style: String::from("boot") },
        ]
    );
}

创建自定义迭代器

实现 Iterator trait
只会从 1 数到 5 的迭代器

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option {
        self.count += 1;

        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}

#[test]
fn calling_next_directly() {
    let mut counter = Counter::new();

    assert_eq!(counter.next(), Some(1));
    assert_eq!(counter.next(), Some(2));
    assert_eq!(counter.next(), Some(3));
    assert_eq!(counter.next(), Some(4));
    assert_eq!(counter.next(), Some(5));
    assert_eq!(counter.next(), None);
}

其他 Iterator trait 方法使用自定义迭代器的next

#[test]
fn using_other_iterator_trait_methods() {
    let sum: u32 = Counter::new()
        // 获取 Counter 实例产生的值
        // 将这些值与另一个 Counter 实例在省略了第一个值之后产生的值配对
        .zip(Counter::new().skip(1))
        // 将每一对值相乘
        .map(|(a, b)| a * b)
        // 只保留那些可以被3整除的结果
        .filter(|x| x % 3 == 0)
        // 将所有保留的结果相加
        .sum();
    assert_eq!(18, sum);
}

zip 只产生四对值；
第五对值 (5, None) 从未被产生
zip 在任一输入迭代器返回 None 时也返回 None