无涯教程-Rust - 迭代&闭包

在本章中，我们将学习RUST中的迭代器和闭包如何工作。

Iterator 迭代器

迭代器有助于迭代值的集合，例如数组，向量，Map映射等，迭代器实现Rust标准库中定义的Iterator trait，iter()方法返回集合的迭代器对象，迭代器对象中的值称为元素，迭代器的next()方法可用于遍历元素，当到达集合末尾时，next()方法将返回值None。

以下示例使用迭代器从数组读取值。

fn main() {
   //声明一个数组
   let a=[10,20,30];

   let mut iter=a.iter(); 
   //获取数组的迭代器对象
   println!("{:?}",iter);

   //从迭代器对象中获取单个值
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
   println!("{:?}",iter.next());
}

Iter([10, 20, 30])
Some(10)
Some(20)
Some(30)
None

如果类似array或Vector的集合实现Iterator trait，则可以使用for ... in语法遍历它，如下所示-

fn main() {
   let a=[10,20,30];
   let iter=a.iter();
   for data in iter{
      print!("{}\t",data);
   }
}

10 20 30

以下3种方法从集合中返回迭代器对象 ，其中T表示集合中的元素。

iter()  函数

iter()函数返回对集合中每个元素的引用，使集合保持不变，并在循环后可以重用。

fn main() {
   let names=vec!["Kannan", "Learnfk", "Kiran"];
   for name in names.iter() {
      match name {
         &"Learnfk" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names); 
   //迭代后重用集合
}

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Learnfk", "Kiran"]

into_iter()  函数

此函数将集合中的值移动到一个iter对象中，即该集合已被使用，并且不再可重用。

fn main(){
   let names=vec!["Kannan", "Learnfk", "Kiran"];
   for name in names.into_iter() {
      match name {
         "Learnfk" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   //迭代后无法重用集合
   //println!("{:?}",names); 
   //错误：所有权转移后无法访问
}

Hello Kannan
There is a rustacean among us!
Hello Kiran

for和iter_mut()  函数

此函数类似于 iter()函数，但是，此函数可以修改集合中的元素。

fn main() {
   let mut names=vec!["Kannan", "Learnfk", "Kiran"];
   for name in names.iter_mut() {
      match name {
         &mut "Learnfk" => println!("There is a rustacean among us!"),
         _ => println!("Hello {}", name),
      }
   }
   println!("{:?}",names);
   ////迭代后重用集合
}

Hello Kannan
There is a rustacean among us!
Hello Kiran
["Kannan", "Learnfk", "Kiran"]

Closure 闭包

闭包是指另一个函数中的一个函数，这些是匿名函数–没有名称的函数，闭包可用于将函数分配给变量，这允许程序将函数作为参数传递给其他函数，闭包也称为内联函数，内联函数可以访问外部函数中的变量。

定义闭包

闭包定义可以可选地具有参数，参数包含在两个垂直条中。

let closure_function=|parameter| {
   //logic
}

调用Closure的语法实现Fn特性。因此，可以使用()语法来调用它。

closure_function(parameter);    //调用

闭包示例1

以下示例在函数 main()中定义了闭包 is_even ，如果数字为偶数，则闭包返回true，如果数字为奇数，则闭包返回false。

fn main(){
   let is_even=|x| {
      x%2==0
   };
   let no=13;
   println!("{} is even ? {}",no,is_even(no));
}

13 is even ? false

闭包示例2

fn main(){
   let val=10; 
   //在外面声明
   let closure2=|x| {
      x + val //访问外部 fn 变量的内部函数
   };
   println!("{}",closure2(2));
}

main()函数声明一个变量 val 和一个闭包，闭包访问在外部函数 main()中声明的变量。

12

参考链接

https://www.learnfk.com/rust/rust-iterator-and-closure.html