rust闭包的使用
作者：int8
一、闭包是什么
（一）闭包是什么
我们先来看看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、FnMut、FnOnce特性中的一个。
闭包有三种捕获方式，Rust会根据捕获方式来决定它们实现的trait。
（1）获取所有权
使用这种方式的闭包实现了FnOnce特性。
闭包获取其所有权并在定义闭包时将其移动进闭包。Once代表了闭包不能多次获取相同变量的所有权，所以它只能被调用一次。
使用这种方式，要在开头添加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! 即可修复问题。
（2）可变借用
使用这种方式的闭包实现了FnMut特性。
因为是可变引用，所以可以改变其环境。
（3）不可变借用
使用这种方式的闭包实现了Fn特性。
因为是不可变引用，所以不可修改其环境。
例子
fn main() {
let x = 5;
let y = 10;
// Fn闭包：通过不可变引用捕获变量
let add = |a| a + x;
// FnMut闭包：通过可变引用捕获变量
let mut multiply = |a| {
x * y * a
};
// FnOnce闭包：通过值捕获变量
let divide = move |a| {
a / y
};
let result1 = add(3);
let result2 = multiply(2);
let result3 = divide(10);
println!("The results are: {}, {}, {}", result1, result2, result3);
}
复合类型（如结构体）始终是全部捕获的，而不是各个字段分开捕获的。如果真要捕获单个字段，那可能需要先借用该字段到本地局部变量中：
struct SetVec {
set: HashSet<u32>,
vec: Vec<u32>
}
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已经被借出用来迭代了，所以代码将无法编译。
3.闭包作为参数和返回值
闭包可以作为函数的参数和返回值，如此使用时，必须指定类型，类型就是上面讲的Fn、FnMut、FnOnce。
（1）作为参数
fn f1(x: impl Fn()){
x();
}
fn f2<F>(x:F)
where
F:Fn()
{
x();
}
fn main() {
f1(||{});
f2(||{});
}
（2）作为返回值
fn f1() -> impl Fn(i32) {
|x|{println!("{}",x)}
}
fn f2() -> impl Fn(i32) {
let a=100;
move |x|{println!("{}",x+a)} //如果使用引用方式捕获，那么返回后a销毁，引用会变成悬垂引用，所以编译器不会通过
}
fn main() {
f1()(9);//9
f2()(9);//109
}到此这篇关于rust闭包的应用场景的文章就介绍到这了,更多相关rust闭包内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！