IT评测·应用市场-qidao123.com技术社区

标题: Rust中的迭代器的使用：map转换、filter过滤、fold聚合、chain链接 [打印本页]

---

作者: 泉缘泉    时间: 2023-4-12 23:21
标题: Rust中的迭代器的使用：map转换、filter过滤、fold聚合、chain链接
什么是迭代器

Rust中的迭代器是一种强大的工具，它提供了一种灵活、通用的方法来遍历序列。迭代器是实现了Iterator trait的类型，并需要至少实现一个next函数，用于让迭代器指向下一个迭代对象，并返回一个Option用于指示对象是否存在。

1. fn next (&mut self) -> Option<Self::Item>;
2. <br>

复制代码

迭代器相比于for循环有一些优势。首先，迭代器提供了一种灵活、通用的方法来迭代序列。它允许你使用各种方法来处理序列中的元素，例如map、filter、fold等。这些方法可以让你更简洁、更清晰地表达你的意图。
此外，迭代器和Rust的所有权系统密切相连。这意味着你可以使用迭代器来安全地处理序列中的元素，而不必担心内存安全问题。
迭代器是Rust的零抽象之一，这意味着迭代器抽象不会引入运行时开销，不会有任何性能上的影响
迭代器可以做什么

Rust中的迭代器可以通过实现Iterator trait来创建，也可以通过调用现有类型的iter方法来获取。例如，Vec提供了一个iter方法，可以返回一个迭代器，用于遍历Vec中的元素。

1. let v = vec![1, 2, 3];
2. for i in v.iter() {
3.     println!("{}", i);
4. }
5. <br>

复制代码

除了for循环外，迭代器还提供了许多其他有用的方法，例如： 迭代器模式允许你对一个项的序列进行某些处理。Rust中的迭代器提供了一种简洁、高效的方式来处理序列，例如通过使用map、filter、fold等方法来转换、过滤和聚合数据。这些方法通常比手写循环更简洁、更易读，也更容易优化。

• map：转换数据。接受一个闭包并为迭代器中的每个元素调用该闭包，然后返回一个新的迭代器，其中包含闭包返回的值。
  

1. let v = vec![1, 2, 3];
2. let v_squared: Vec<i32> = v.iter().map(|x| x * x).collect();
3. <br>

复制代码

• filter：过滤数据。接受一个闭包并为迭代器中的每个元素调用该闭包。如果闭包返回true，则元素将包含在新的迭代器中。
  

1. let v = vec![1, 2, 3];
2. let v_even: Vec<&i32> = v.iter().filter(|x| *x % 2 == 0).collect();
3. <br>

复制代码

• fold：聚合数据。接受一个初始值和一个闭包，并将闭包应用于初始值和迭代器中的每个元素，以生成一个单一的最终值。
  

1. let v = vec![1, 2, 3];
2. let sum: i32 = v.iter().fold(0, |acc, x| acc + x);
3. <br>

复制代码

• chain：该方法是Iterator trait的一个方法，它允许你将两个迭代器链接在一起，形成一个新的迭代器。这个新的迭代器会先遍历第一个迭代器中的所有元素，然后再遍历第二个迭代器中的所有元素。
  

例如，你可以使用chain方法将两个数组中的元素链接在一起：

1. let a = [1, 2, 3];
2. let b = [4, 5];
3. let c: Vec<i32> = a.iter().chain(b.iter()).copied().collect();
4. assert_eq!(c, [1, 2, 3, 4, 5]);
5. <br>

复制代码

在这个例子中，我们创建了两个数组a和b，然后使用chain方法将它们链接在一起，形成一个新的迭代器。最后，我们使用collect方法将迭代器中的元素收集到一个向量中。
希望这对你有所帮助。 ## 如何创建一个迭代器 要创建一个迭代器，你需要给一个类型实现Iterator trait，并实现next方法。下面是一个例子，它展示了如何在一个斐波那契数列类型上创建迭代器：

1. struct Fib {
2.     a: i32,
3.     b: i32,
4. }
6. impl Iterator for Fib {
7.     type Item = i32;
9.     fn next(&mut self) -> Option<Self::Item> {
10.         let res = self.a;
11.         self.a = self.b;
12.         self.b = res + self.b;
13.         Some(res)
14.     }
15. }
17. fn main() {
18.     let fib = Fib { a: 1, b: 1 };
19.     for i in fib.take(10) {
20.         println!("{}", i);
21.     }
22. }
23. <br>

复制代码

这个例子中，我们定义了一个Fib结构体，它包含两个字段a和b。然后我们为Fib结构体实现了Iterator trait，并实现了next方法。在next方法中，我们计算出下一个斐波那契数，并返回它。最后，在main函数中，我们创建了一个Fib实例，并使用take方法获取前10个斐波那契数1。
使用迭代器要注意什么

在使用Rust中的迭代器时，有几点需要注意：

• 迭代器是惰性的：迭代器不会立即计算它们的值，而是在调用next方法时才会计算。这意味着你需要调用collect或其他消耗迭代器的方法来获取最终结果，这里有一个详细的例子来解释迭代器的惰性：
  

1. fn main() {
2.     let v = vec![1, 2, 3];
3.     let v_iter = v.iter().map(|x| {
4.         println!("Mapping value: {}", x);
5.         x * 2
6.     });
8.     println!("Created iterator");
10.     for val in v_iter {
11.         println!("Got value: {}", val);
12.     }
13. }
14. <br>

复制代码

在这个例子中，我们创建了一个迭代器v_iter，它使用map方法将序列中的每个元素乘以2。注意，在创建迭代器时，我们并没有看到任何输出。这是因为迭代器是惰性的，它不会立即计算它们的值。
接下来，我们使用for循环来打印出计算后结果。在这个过程中，我们可以看到输出。这是因为for循环会调用迭代器的next方法来获取下一个值。在调用next方法时，迭代器才会计算它的值。

• 注意所有权和借用：当你使用迭代器时，需要注意所有权和借用规则。例如，如果你想要在迭代器中修改元素，你需要使用iter_mut而不是iter方法。
  

1. let mut v = vec![1, 2, 3];
2. for i in v.iter_mut() {
3.    *i *= 2;
4. }
5. <br>

复制代码

• 注意迭代器失效：当你修改了迭代器所指向的集合时，迭代器可能会失效。例如，如果你在遍历Vec的同时向其中添加元素，可能会导致迭代器失效。 下面是一个例子，它展示了如何在遍历Vec的同时向其中添加元素，导致迭代器失效：
  

1. fn main() {
2.     let mut v = vec![1, 2, 3];
3.     let mut v_iter = v.iter_mut();
5.     while let Some(val) = v_iter.next() {
6.         println!("Got value: {}", val);
7.         if *val == 2 {
8.             v.push(4);
9.         }
10.     }
11. }
12. <br>

复制代码

在这个例子中，我们创建了一个可变迭代器v_iter来遍历Vec。然后我们使用while循环来遍历迭代器。在遍历过程中，当我们遇到值为2的元素时，我们向Vec中添加了一个新元素。
然而，在Rust中，这样的操作是不允许的。当你运行这段代码时，你会得到一个运行时错误，提示你迭代器已经失效。

• 注意性能问题：虽然迭代器通常比手写循环更简洁、更易读，但它们并不总是最快的。如果性能至关重要，你应该测试不同的实现方式，并选择最快的一种。 例如，下面是两个计算1到10的和的例子：
  

1. fn main() {
2.     let sum: i32 = (1..11).sum();
3.     println!("{}", sum);
5.     let mut sum = 0;
6.     for i in 1..11 {
7.         sum += i;
8.     }
9.     println!("{}", sum);
10. }
11. <br>

复制代码

第一个例子使用了迭代器来计算和，而第二个例子使用了手写循环。在大多数情况下，这两个例子的性能差异并不明显。但是，在某些情况下，手写循环可能会比迭代器更快。单数使用迭代器比使用for循环更简洁，并且保证内存安全
总之，Rust中的迭代器是一种强大的工具，它提供了一种简洁、高效、安全的方式来操作数据。在使用迭代器时，应注意惰性、所有权和借用、迭代器失效和性能问题。 from刘金，转载请注明原文链接。感谢！

• 注意性能问题：虽然迭代器通常比手写循环更简洁、更易读，但它们并不总是最快的。如果性能至关重要，你应该测试不同的实现方式，并选择最快的一种。 例如，下面是两个计算1到10的和的例子：
  

1. fn main() {
2.     let sum: i32 = (1..11).sum();
3.     println!("{}", sum);
5.     let mut sum = 0;
6.     for i in 1..11 {
7.         sum += i;
8.     }
9.     println!("{}", sum);
10. }
11. 复制代码

复制代码

第一个例子使用了迭代器来计算和，而第二个例子使用了手写循环。在大多数情况下，这两个例子的性能差异并不明显。但是，在某些情况下，手写循环可能会比迭代器更快。单数使用迭代器比使用for循环更简洁，并且保证内存安全
总之，Rust中的迭代器是一种强大的工具，它提供了一种简洁、高效、安全的方式来操作数据。在使用迭代器时，应注意惰性、所有权和借用、迭代器失效和性能问题。from刘金，转载请注明原文链接。感谢！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/)

Powered by Discuz! X3.4