rust闭包

一、闭包是什么

（一）闭包是什么
我们先来看看javascript中的闭包。
在函数外部无法读取函数内的局部变量。但是我们有时候需要得到函数内的局部变量，那么如何从外部读取局部变量？那就是在函数的内部，再定义一个函数。

function f1(){
	var n=999;
	function f2(){
		alert(n);
	}
}

在上面的代码中，函数f2在函数f1内部，这时f1内部的所有局部变量，对f2都是可见的。但是反过来就不行，f2内部的局部变量，对f1就是不可见的。这就是"链式作用域"，子作用域会一级一级地向上寻找所有父作用域的变量。
既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！

function f1(){
	var n=999;
	function f2(){
		alert(n);
	}
	return f2;
}
var result=f1();//实际上f1()执行完之后，并没有释放内存，n还在
result(); // 999。执行f2()，能访问f1中的n

上一节代码中的f2函数，就是闭包。
各种专业文献上的"闭包"定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。
由于只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成"定义在一个函数内部的函数"。
所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。

闭包可以读取函数内部的变量，可以让这些变量的值始终保持在内存中。
f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制回收。

（二）闭包的优缺点
优点：
直接访问父作用域中的局部变量，避免了传参的问题
逻辑连续，避免脱离当前逻辑，在外部编写代码
缺点：
因为使用闭包，可以使函数在执行完后不被销毁，保留在内存中，如果大量使用闭包就会造成内存泄露，内存消耗很大

（三）使用场景
（1）设置timer
（2）用后即弃的一次性功能，没必要另外写个函数

（四）思考题
如果你能理解下面两段代码的运行结果，应该就算理解闭包的运行机制了。
代码片段一。

var name = "The Window";
var object = {
	name : "My Object",
	getNameFunc : function(){
		return function(){
			return this.name;
		};
	}
};
alert(object.getNameFunc()());

代码片段二。

var name = "The Window";
var object = {
	name : "My Object",
	getNameFunc : function(){
		var that = this;
		return function(){
			return that.name;
		};
	}
};
alert(object.getNameFunc()());

第一个 打印结果为The window
第二个 打印结果为My Object
this是由它所在函数调用时的环境决定的，而不是由它所在函数定义的环境决定的。
第一个this是在调用闭包时确定的，环境是全局环境
第二个this是在调用getNameFunc时确定的，环境是object内

二、rust闭包

rust闭包，跟javascript闭包原理基本一样。就语法格式不一样。
rust闭包没有名字，包含于一个函数内。
所以可以直接认为rust闭包是一个没有函数名的内联函数。

（一）定义闭包
它的定义语法如下

|parameter| {
     // 闭包的具体逻辑
}

闭包不要求在参数和返回值上注明类型
例子

|x: u32| -> u32 { x + 1 }
|x|             { x + 1 }
|x|               x + 1  

闭包虽然没有名称，但我们可以将闭包赋值给一个变量

let closure_function = |parameter| {
     // 闭包的具体逻辑
}

（二）使用闭包
1.使用小括号 () 来调用闭包

closure_function(parameter);

范例：

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;
     // 访问外层作用域变量val
     let closure2 = |x| {
         x + val // 内联函数访问外层作用域变量
     };
     println!("{}", closure2(2));
}
编译运行结果如下
12

Fn系列trait由标准库提供。所有的闭包都实现了Fn、FnMut、FnOnce中的一个。
闭包可以通过三种方式捕获其环境中的变量：
获取所有权，可变借用和不可变借用。这三种方式被编码为如下三个trait

• FnOnce消耗捕获的变量。为了消费捕获到的变量，闭包必须获取其所有权并在定义闭包时将其移动进闭包。Once代表了闭包不能多次获取相同变量的所有权，所以它只能被调用一次。
• FnMut获取可变的借用值所以可以改变其环境
• Fn从其环境获取不可变的借用值

当你创建闭包时，Rust 会根据闭包使用环境中变量的方式来自动推导出它们需要使用的 trait。所有闭包都自动实现了 FnOnce，因为它们至少都可以被调用一次。那些不需要移动被捕获变量的闭包还会实现 FnMut，而那些不需要修改被捕获变量的闭包则同时实现了Fn。
如果你希望强制闭包获取所有权，可以在参数列表前使用move关键字。关键字move通常用于允许闭包比其捕获的值活得更久，例如返回闭包或用于生成新线程。
例子

fn main() {
     let x = vec![1, 2, 3];
     let equal_to_x = move |z| z == x;
     println!("can't use x here: {:?}", x);//编译错误
     let y = vec![1, 2, 3];
     assert!(equal_to_x(y));
}

x被移动进了闭包，因为闭包使用move关键字定义。接着闭包获取了x的所有权，同时main就不再允许在println! 语句中使用x了。去掉println! 即可修复问题。

复合类型（如结构体）始终是全部捕获的，而不是各个字段分开捕获的。如果真要捕获单个字段，那可能需要先借用该字段到本地局部变量中：

struct SetVec {
     set: HashSet,
     vec: Vec
}
impl SetVec {
     fn populate(&mut self) {
         let vec = &mut self.vec;
         self.set.iter().for_each(|&n| {
             vec.push(n);
         })
     }
}

相反，如果闭包直接使用了self.vec，那么它将尝试通过可变引用捕获self。但是因为self.set已经被借出用来迭代了，所以代码将无法编译。