Rust 闭包 Closure-六虎

闭包这个词语由来已久，被广泛用于函数式编程言语中，各种现代化的编程言语也都不约而同地把闭包作为中心特性归入到言语设计中来。闭包是一种匿名函数，能够赋值给变量也能够作为参数传递给其它函数，不同于函数的是，它答应捕获调用者效果域中的值（捕获环境中的自在变量）。换句话说，闭包是由函数和与其相关的引证环境组合而成的实体

fn main() {
   let x = 1;
   let sum = | y | x + y;
    assert_eq!(3, sum(2));
}

上面的代码展现了十分简略的闭包sum，它具有一个入参y，一起捕获了效果域中的x的值，因而调用sum(2)意味着将 2（参数y）跟 1（x）进行相加，终究回来它们的和：3。

能够看到sum十分契合闭包的界说：能够赋值给变量，答应捕获调用者效果域中的值。

Rust闭包与函数最大的不同便是参数通过|parm1|的形式进行声明，假如是多个参数便是|parm1, parm2, ... |，闭包的形式界说如下：

//闭包的形式界说
|parm1, parm2, ... | {
	语句1;
	语句2;
	回来表达式
}
//假如只要一个回来表达式，界说能够简化为
|parm1| 回来表达式

闭包：|parm1|代表传入参数，->后边代表返加值，{}大括号里代表函数体

闭包由一个结构体组成，当引证了外部的自在变量时便是有巨细的，并且引证的是指针；假如没有引证外部自在变量，便是一个空的结构体，巨细便是0。一切闭包名称都是仅有的。Rust 闭包底层是用结构体完成的。那么闭包是怎么找到函数的？实际上是在内部直接写死了函数指针的地址，这是在编译期完成的操作。

Rust 中的闭包耦合了泛型、生命周期和一切权，一切这些都是为了保证程序运行时的安全和效率。

闭包的类型推导

开发者有必要手动为函数的一切参数和回来值指定类型，由于函数一般作为API提供给用户，可是闭包并不会作为API对外提供，因而能够享用编译器的类型推导能力而无需标示参数和回来值的类型。尽管编译器会对闭包进行类型推导，可是当推导出一种类型后，就会一直运用该类型，当传入其他类型参数时就会报错。

// 同一功用的函数和闭包完成形式：
fn add_one_v1 (x: i32) -> i32 { x + 1 }
let add_one_v2 = |x: i32| -> i32 { x + 1 };  // 与函数最像
let add_one_v3 = |x| { x + 1 };  // 省掉参数和回来值
let add_one_v4 = |x| x + 1;  // 省掉花括号对

能够看出第一行的函数和后边的闭包其实在形式上是十分接近的，一起三种不同的闭包也展现了三种不同的运用方法：省掉参数、回来值类型和花括号对。

尽管类型推导很好用，可是它不是泛型，编译器会为闭包界说中的每个参数和回来值推断一个详细类型，当编译器推导出一种类型后，它就会一直运用该类型：

闭包捕获变量的方法

当闭包从环境中捕获一个值时，会分配内存去存储这些值。关于有些场景来说，这种额外的内存分配会成为一种担负。

闭包捕获变量有三种方法，刚好对应函数参数的三种传入方法：搬运一切权、可变借用、不可变借用。与此相对应的Fn特征也有三种：FnOnce、FnMut、和Fn。闭包会依据函数体中怎么运用被捕获的变量决定用哪种Fn特征。

1. FnOnce

FnOnce类型的闭包会拿走被捕获变量的一切权，Once说明闭包只能运行一次。仅完成FnOnce特征的闭包在调用时会搬运一切权，所以不能对已失去一切权的闭包变量进行二次调用。

可是假如闭包完成了Copy特征，那么调用时运用的将是拷贝，并没有发生一切权的搬运，所以能够屡次调用。比如：

fn main() {
    let x = vec![1, 2, 3];
    fn_once(|z| {z == x.len()});
}
// 此处声明闭包func完成了 Copy，闭包没有发生一切权搬运一切func调用两次不崩溃
fn fn_once<F: FnOnce(usize) -> bool + Copy> (func: F) {
    println!("{}", func(3)); // true
    println!("{}", func(4)); // false
}

假如想强制搬运变量的一切权(重点了解捕获变量x一切权与闭包func一切权的区别)到闭包内部，能够在参数列表前增加move关键字，一般要求闭包生命周期大于捕获变量声明周期场景，如将闭包回来或移入其他线程。比如：

use std::thread;
fn main() { 
  let v = vec![1, 2, 3];
  let handle = thread::spawn(move || { // move 关键字搬运环境中的变量v到线程内部
      println!("Here's a vector: {:?}", v);
  });
  handle.join().unwrap();
}

2. FnMut

FnMut 表示以可变引证（&mut T）的方法捕获了环境中的值，因而能够修改该值。要完成可变借用捕获变量，需要将该闭包声明为可变类型，把闭包当做一个普通变量。可变类型闭包式例：

fn main() {
    let mut s = String::new();
    let mut update_string = |str| s.push_str(str); // 闭包仅对环境中变量s进行了可变借用:&mut s
    update_string("hello"); 
    println!("{:?}", s); // "hello"
    let update_string = |str| s.push_str(str);  // 闭包对环境中变量s进行了可变借用:&mut s，即闭包是FnMut特征 
    exec(update_string); // 将`FnMut`闭包作为函数传入参数示例：
    println!("{:?}", s); // "helloworld"
}
// 希望函数传参进来的闭包完成的是`FnMut`
fn exec<'a, F: FnMut(&'a str)> (mut func: F)  {
    func("world") 
}

3. Fn

Fn 表示以不可变引证（&T）的方法捕获环境中的值。 下为示例；

fn main() {
    let s = "hello, ".to_string();
    let update_string =  |str| println!("{},{}",s,str);  // 闭包对环境中变量s进行了不可变借用，相当于&s，即闭包是Fn特征的
    exec(update_string);
    println!("{:?}",s);
}
// 希望传参进来一个Fn特征的闭包
fn exec<'a, F: Fn(String) -> ()>(func: F)  {  // 关于不可变借用闭包，仅将其标记为Fn特征即可
    func("world".to_string())
}

能够在闭包的参数列表前运用move关键字，这样将强制闭包以获取一切权的方法捕获其环境中的变量，不过运用了move的闭包仍然可能完成了Fn和FnMut，由于一个闭包完成了哪种 Fn 特征取决于该闭包内部怎么运用被捕获的变量，而不是取决于闭包怎么捕获它们。运用的move关键字，着重的便是“闭包怎么捕获变量”。

fn main() {
    let s = String::new();
    let update_string =  move || println!("{}",s);
    exec(update_string);
}
fn exec<F: FnOnce()>(f: F)  {
    f()
}

例如上面的代码中，闭包不只是完成了FnOnce特征，还完成了Fn特征（由于该闭包关于s的运用只是是不可变引证），因而将代码中的FnOnce修改为Fn也是能够编译通过的。

实际上，一个闭包并不只是完成了某一种Fntrait，其规矩如下：

一切的闭包都主动完成了 FnOnce trait，因而任何一个闭包都至少能够被调用一次；
没有移出所捕获变量的一切权的闭包主动完成了 FnMut trait；
不需要对捕获变量进行改动的闭包主动完成了 Fn trait。

用一段代码来简略诠释上述规矩：

fn main() {
    let s = String::new();
    let update_string =  || println!("{}",s); // 闭包进行了不可变借用，没有移出变量一切权，不改动变量
    exec(update_string);
    exec1(update_string);
    exec2(update_string);
}
fn exec<F: FnOnce()>(f: F)  { // 规矩1: 一切闭包主动完成FnOnce
    f()
}
fn exec1<F: FnMut()>(mut f: F)  {// 规矩2: 没有移出捕获变量一切的闭包主动完成FnMut
    f()
}
fn exec2<F: Fn()>(f: F)  {// 规矩3: 不需要对捕获变量进行改动的主动完成Fn
    f()
}

尽管，闭包只是对s进行了不可变借用，实际上，它能够适用于任何一种Fntrait；

一个移出一切权的例子：

fn main() {
    let mut s = String::new();
    let update_string = |str| -> String { s.push_str(str); s }; // 移出了s一切权
    exec(update_string);
}
fn exec<'a, F: FnMut(&'a str) -> String>(mut f: F) {  // 过错，完成了FnOnce
    f("hello");
}

示例代码中，闭包从捕获环境中移出了变量s的一切权，并进行改动，因而闭包只完成了 FnOnce，未完成 FnMut 和 Fn。

我们来看看这三个特征的简化版源码：

pub trait Fn<Args> : FnMut<Args> { // Fn 完成了 FnMut
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}
pub trait FnMut<Args> : FnOnce<Args> { // FnMut 完成了 FnOnce
    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}
pub trait FnOnce<Args> {
    type Output;
    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

从源码中还能看出：Fn获取&self，FnMut获取&mut self，而FnOnce获取self。

结论：Fn 的条件是完成 FnMut，FnMut 的条件是完成 FnOnce，因而要完成 Fn 就要一起完成 FnMut 和 FnOnce。在实际项目中，主张先运用Fn，然后编译器会告诉你正误以及该怎么挑选

闭包作为函数回来值

Rust要求函数的参数和回来类型，有必要有固定的内存巨细。绝大部分类型都有固定的巨细，可是不包括trait，由于编译器无法知道其实在类型或详细巨细，因而编译器会提示运用impl关键字，如：

fn return_closure(x: i32) -> impl Fn(i32) -> i32 {
    let num = 5;
    if x > 1{
        move |x| x + num
    } else {
        move |x| x - num
    }
}

可是上面代码不能通过，由于两个分支回来了不同的闭包类型。即使是签名相同的闭包，类型也是不同的。能够用Box完成特征对象：

fn factory(x:i32) -> Box<dyn Fn(i32) -> i32> {  // dyn是声明trait对象类型的关键字
    let num = 5;
    if x > 1{
        Box::new(move |x| x + num)
    } else {
        Box::new(move |x| x - num)
    }
}

闭包类型占用内存的巨细

假如把闭包了解成一个结构体，闭包所捕获的变量相当于结构体中的字段，则闭包的巨细就和闭包参数，闭包代码的局部变量都没有关系，而只与闭包从其环境中捕获的变量有关。

总结

Rust 的闭包（closures）是能够保存在一个变量中或作为参数传递给其他函数的匿名函数，通俗的说便是一个能够从环境中捕获变量的匿名函数。能够在一个地方创建闭包，然后在不同的上下文中执行闭包运算。不同于函数，闭包答应捕获被界说时所在效果域中的值。

闭包捕获变量的方法分为三类：不可变引证（&T）、可变引证（&mut T）和值（T），与此相对应的 trait 也有三种：Fn、FnMut、和FnOnce，

Fn— 变量不可变借用，只读不答应修改闭包的内部数据，闭包可调用屡次
FnMut— 变量可变借用，答应在执行时修改闭包的内部数据，闭包可调用屡次
FnOnce— 变量移动，获得一切权，闭包只可调用一次

注：关于闭包|| a.x + 1，2018的完成是捕获整个结构体a，可是现在只捕获所需要用的x。这个特性会导致一些对象在不一起间点被释放（dropped），或是影响了闭包是否完成Send或Clonetrait，所以 cargo 会插入语句let _ = &a引证完好结构体来修正这个问题。这个变化其实很大，细节能够参阅官方文档。

参阅

/editor/draf…
kaisery.github.io/trpl-zh-cn/…
rustwiki.org/zh-CN/refer…
rustwiki.org/zh-CN/rust-…
mytechshares.com/2021/09/12/…
nihil.cc/posts/rust_…
zhauniarovich.com/post/2020/2…

Rust 闭包 Closure

闭包的类型推导

闭包捕获变量的方法

1. FnOnce

2. FnMut

3. Fn

闭包作为函数回来值

闭包类型占用内存的巨细

总结

参阅

相关文章

从零开始学Python第06课：循环结构

概率分析：为什么葫芦娃救爷爷是一个一个地救成功率最高？

【HTTP协议】HTTP协议初体验，深入浅出网络协议

从互联网到国企、从一线城市到三线省会

作者信息