Option与Result<T, E>、迭代器

你好，我是Mike，今天我们一起来重点学习在Rust中高频使用的 Option<T>、 Result<T, E>、迭代器，通过学习这些内容，我们可以继续夯实集合中所有权相关的知识点。

Option<T> 和 Result<T, E> 并不是Rust的独创设计，在Rust之前，OCaml、Haskell、Scala等已经使用它们很久了。新兴的一批语言Kotlin、Swift 等也和Rust一样引入了这两种类型。而C++17之后也引入了它们。

这其实能说明使用 Option<T> 和 Result<T, E> 逐渐成了编程语言圈子的一种新共识。而迭代器已经是目前几乎所有主流语言的标配了，所以我们也来看看Rust中的迭代器有什么独到的地方。

如果你习惯了命令式编程或OOP编程，那么这节课我们提到各种操作对你来说可能有点陌生，不过也不用担心，这节课我设计了大量示例，你可以通过熟悉这些示例代码，掌握Rust中地道的编程风格。

迭代器

迭代器其实很简单，就是对一个集合类型进行遍历。比如对 Vec<T>、对 HashMap<K, V> 等进行遍历。使用迭代器有一些好处，比如：

按需使用，不需要把目标集合一次性全部加载到内存，使用一点加载一点。
惰性计算，可以用来表达无限区间，比如第一讲我们说的range，可以表达1到无限这个集合，这种在其他有些语言中很难表达。
可以安全地访问边界，不需要使用有访问风险的下标操作符。

`next()` 方法

迭代器上有一个标准方法，叫作 next()，这个方法返回 Option<Item>，其中 Item 就是组成迭代器的元素。这个方法的字面意思就是 迭代出下一个元素。如果这个集合被迭代完成了，那么最后一次执行会返回 None。比如下面的例子，在迭代器上调用 .next() 返回 u32 数字。

fn main() {
    let a: Vec<u32> = vec![1, 2, 3, 4, 5];
    let mut an_iter = a.into_iter();    // 将Vec<u32>转换为迭代器

    while let Some(i) = an_iter.next() {  // 调用 .next() 方法
        println!("{i}");
    }
}
// 输出
1
2
3
4
5

实际上，Rust中不止 into_iter() 这一种将集合转换成迭代器的方法。

`iter()`、 `iter_mut()`、 `into_iter()` 与三种迭代器

Rust中的迭代器根据所有权三态可以分成三种。

获取集合元素不可变引用的迭代器，对应方法为 iter()。
获取集合元素可变引用的迭代器，对应方法为 iter_mut()。
获取集合元素所有权的迭代器，对应方法为 into_iter()。

在Rust标准库约定中，如果你看到一个类型上实现了 iter() 方法，那么它会返回获取集合元素不可变引用的迭代器；如果你看到一个类型上实现了 iter_mut() 方法，那么它会返回获取集合元素可变引用的迭代器；如果你看到一个类型上实现了 into_iter() 方法，那么它会返回获取集合元素所有权的迭代器。调用了这个迭代器后，迭代器的执行会消耗掉原集合。

我们来看这三种不同的迭代器的一个对比。

fn main() {
    let mut a = [1, 2, 3];    // 一个整数数组

    let mut an_iter = a.iter();  // 转换成第一种迭代器

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

    let mut an_iter = a.iter_mut();  // 转换成第二种迭代器

    assert_eq!(Some(&mut 1), an_iter.next());
    assert_eq!(Some(&mut 2), an_iter.next());
    assert_eq!(Some(&mut 3), an_iter.next());
    assert_eq!(None, an_iter.next());

    let mut an_iter = a.into_iter();  // 转换成第三种迭代器，并消耗掉a

    assert_eq!(Some(1), an_iter.next());
    assert_eq!(Some(2), an_iter.next());
    assert_eq!(Some(3), an_iter.next());
    assert_eq!(None, an_iter.next());

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

你还可以与字符串数组进行对比加深理解。

fn main() {
    let mut a = ["1".to_string(), "2".to_string(), "3".to_string()];
    let mut an_iter = a.iter();

    assert_eq!(Some(&"1".to_string()), an_iter.next());
    assert_eq!(Some(&"2".to_string()), an_iter.next());
    assert_eq!(Some(&"3".to_string()), an_iter.next());
    assert_eq!(None, an_iter.next());

    let mut an_iter = a.iter_mut();

    assert_eq!(Some(&mut "1".to_string()), an_iter.next());
    assert_eq!(Some(&mut "2".to_string()), an_iter.next());
    assert_eq!(Some(&mut "3".to_string()), an_iter.next());
    assert_eq!(None, an_iter.next());

    let mut an_iter = a.into_iter();

    assert_eq!(Some("1".to_string()), an_iter.next());
    assert_eq!(Some("2".to_string()), an_iter.next());
    assert_eq!(Some("3".to_string()), an_iter.next());
    assert_eq!(None, an_iter.next());

    println!("{:?}", a);    // 请你试试这一行有没有问题？
}

对于整数数组 [1,2,3] 而言，调用 into_iter() 实际会复制一份这个数组，再将复制后的数组转换成迭代器，并消耗掉这个复制后的数组，因此最后的打印语句能把原来那个a打印出来。对于字符串数组 ["1".to_string(), "2".to_string(), "3".to_string()] 而言，调用 into_iter() 会直接消耗掉这个字符串数组，因此最后的打印语句不能把原来那个a打印出来。

为什么会有这个差异呢？你可以从我们第 2 讲所有权相关知识中找到答案。

for 语句的真面目

有了迭代器的背景知识后，我们终于要解开Rust语言里面for语句的真面目了。for语句是一种语法糖。语句 for item in c {} 会展开成下面这样：

let mut tmp_iter = c.into_iter();
while let Some(item) = tmp_iter.next() {}

也就是说，for语句默认使用获取元素所有权的迭代器模式，自动调用了 into_iter() 方法。因此，for语句会消耗集合 c。同时也说明，要将一个类型放在for语句里进行迭代，需要这个类型实现了迭代器 into_iter() 方法。

标准库中常见的 Range、Vec、HashMap、BtreeMap等都实现了 into_iter() 方法，因此它们可以放在for语句里进行迭代。

for语句作为一种基础语法，它会消耗掉原集合。有时候希望不获取原集合元素所有权，比如只是打印一下，这时只需要获取集合元素的引用，应该怎么办呢？

Rust中也考虑到了这种需求，提供了配套的辅助语法。

用 for in &c {} 获取元素的不可变引用，相当于调用 c.iter()。
用 for in &mut c {} 获取元素的可变引用，相当于调用 c.iter_mut()。

用这两种形式就不会消耗原集合所有权。

我们来看示例。

fn main() {
    let mut a = ["1".to_string(), "2".to_string(), "3".to_string()];

    for item in &a {
        println!("{}", item);
    }

    for item in &mut a {
        println!("{}", item);
    }

    for item in a {    // 请想一想为什么要把这一句放在后面
        println!("{}", item);
    }

    // println!("{:?}", a);  // 你可以试试把这一句打开
}
// 输出
1
2
3
1
2
3
1
2
3

因为 into_iter() 会消耗集合所有权，因此在上面示例中我们把它放在最后去展示。

获取集合类型中元素的所有权

我们来看一个简单的例子，一般来说，我们想要获取Vec里的一个元素，只需要下标操作就可以了。

fn main() {
    let s1 = String::from("aaa");
    let s2 = String::from("bbb");
    let s3 = String::from("ccc");
    let s4 = String::from("ddd");

    let v = vec![s1, s2, s3, s4];
    let a = v[0];    // 这里，我们想访问 s1 的内容
}

这段代码稀松平常，在Rust中却没办法编译通过。

error[E0507]: cannot move out of index of `Vec<String>`
  --> src/main.rs:11:13
   |
11 |     let a = v[0];
   |             ^^^^ move occurs because value has type `String`, which does not implement the `Copy` trait
   |
help: consider borrowing here
   |
11 |     let a = &v[0];
   |             +

提示不能从 Vec<String> 中用下标操作符移出元素。我们改一下代码。

fn main() {
    let s1 = String::from("aaa");
    let s2 = String::from("bbb");
    let s3 = String::from("ccc");
    let s4 = String::from("ddd");

    let v = vec![s1, s2, s3, s4];
    let a = &v[0];  // 明确a只获得v中第一个元素的引用
}

明确a只获得v中第一个元素的引用，这下可以编译通过了。这里，你可以顺便思考一下，对于 Vec<u32> 这种类型的动态数组，let a = v[0]; 这种代码可以编译通过吗？你可以立即动手测试一下。

在上面示例中，你可能为了从集合中获得 s1 的所有权，而不得不使用 let a = v[0].clone()。而根据我们这节课讲的迭代器知识，使用 into_iter() 就可以拿到并操作上述动态数组v中元素的所有权。

fn main() {
    let s1 = String::from("aaa");
    let s2 = String::from("bbb");
    let s3 = String::from("ccc");
    let s4 = String::from("ddd");

    let v = vec![s1, s2, s3, s4];
    for s in v {      // 这里，s拿到了集合元素的所有权
        println!("{}", s);
    }
}

这也体现了Rust对权限有相当细致的管理。对于下标索引这种不安全的操作，禁止获得集合元素所有权；对于迭代器这种安全的操作，允许它获得集合元素所有权。

小结

我们这节课详细探讨了Rust中的 Option<T> 和 Result<T, E> 的定义及常见操作。学习了如何以解包和不解包方式使用它们。内容比较细，风格可能也是你不太熟悉的。不过现在你只需要先了解这种代码风格，以后的项目实践中再慢慢掌握它们。

我们还介绍了迭代器的概念。迭代器的 next() 方法会返回一个 Option<Item> 类型。在所有权三态理论的指导下Rust中的迭代器也划分成了三种，可以通过不同的方法获取到集合元素的不可变引用、可变引用和所有权，这是Rust和其他语言的迭代器很不一样的地方。每种迭代器都有各自适用的场景，正确使用迭代器能提高代码的可靠性和可阅读性。

学习完这节课的内容之后，你应该能更深刻地感受到所有权概念在Rust语言中的支配地位。

思考题

你可以用同样的思路去研究一下，看看如何拿到 HashMap 中值的所有权。

https://doc.rust-lang.org/std/collections/struct.HashMap.html

欢迎你把你的成果展示在评论区，也欢迎你把这节课的内容分享给需要的朋友，邀他一起学习，我们下节课再见！

Rust语言从入门到实战

Option与Result<T, E>、迭代器

`Option<T>` 与 `Result<T, E>`

`Option<T>` 的定义

`Result<T, E>` 的定义

解包

不解包的情况下如何操作？

`Option<T>` 与 `Result<T, E>` 的相互转换

`从Option<T>` 到 `Result<T, E>：ok_or()`

从 `Result<T, E>` 到 `Option<T>：ok()`

从 `Result<T, E>` 到 `Option<T>：err()`

迭代器

`next()` 方法

`iter()`、 `iter_mut()`、 `into_iter()` 与三种迭代器

for 语句的真面目

获取集合类型中元素的所有权

小结

思考题