rust闭包(Closure)

news/2024/12/23 4:55:42/

闭包(Closure)

闭包在现代化的编程语言中普遍存在。闭包是一种匿名函数，它可以赋值给变量也可以作为参数传递给其它函数，不同于函数的是，它允许捕获调用者作用域中的值。Rust 闭包在形式上借鉴了 Smalltalk 和 Ruby 语言，与函数最大的不同就是它的参数是通过 |parm1| 的形式进行声明，如果是多个参数就 |param1, param2,…|， 下面给出闭包的形式定义：

|param1, param2,...| {语句1;语句2;返回表达式
}

如果只有一个返回表达式的话，定义可以简化为：

|param1| 返回表达式
  1. 闭包可以接受0个或者多个参数，写在||里面；
  2. 闭包体中是实际执行的代码；
  3. 闭包可以捕获任何它周围作用域中的变量，并在闭包体中使用。

闭包的类型推导

Rust 是静态语言，因此所有的变量都具有类型，但是得益于编译器的强大类型推导能力，在很多时候我们并不需要显式地去声明类型，但是显然函数并不在此列，必须手动为函数的所有参数和返回值指定类型，原因在于函数往往会作为 API 提供给你的用户，因此你的用户必须在使用时知道传入参数的类型和返回值类型。

与函数相反，闭包并不会作为 API 对外提供，因此它可以享受编译器的类型推导能力，无需标注参数和返回值的类型。

为了增加代码可读性，有时候我们会显式地给类型进行标注，出于同样的目的，也可以给闭包标注类型：

let sum = |x: i32, y: i32| -> i32 {x + y
}

下面展示了同一个功能的函数和闭包实现形式：

fn  add_one_v1   (x: u32) -> u32 { x + 1 }      // 函数
let add_one_v2 = |x: u32| -> u32 { x + 1 };     // 闭包形式1
let add_one_v3 = |x|             { x + 1 };     // 闭包形式2
let add_one_v4 = |x|               x + 1  ;     // 闭包形式3

三种不同的闭包也展示了三种不同的使用方式：省略参数、返回值类型和花括号对。

结构体中的闭包

假设我们要实现一个简易缓存，功能是获取一个值，然后将其缓存起来，那么可以这样设计：

一个闭包用于获取值
一个变量，用于存储该值
可以使用结构体来代表缓存对象，最终设计如下：

struct Cacher<T>
whereT: Fn(u32) -> u32,
{query: T,value: Option<u32>,
}

这里的T的特征约束Fn(u32) -> u32有点像C++中声明函数指针类型，标准库提供的 Fn 系列特征，再结合特征约束，就能很好的解决了这个问题. T: Fn(u32) -> u32 意味着 query 的类型是 T，该类型必须实现了相应的闭包特征 Fn(u32) -> u32。约束表明该闭包拥有一个u32类型的参数，同时返回一个u32类型的值。Fn 特征不仅仅适用于闭包，还适用于函数，因此上面的 query 字段除了使用闭包作为值外，还能使用一个具名的函数来作为它的值。下面的例子将上面的u32类型换成了泛型，可以用来缓存各种数据类型。

use std::fmt::Debug;#[allow(unused)]
fn main() {let x = "Hello World!".to_string();let mut cache = Cacher::new(|x| -> String {x});cache.value(x);println!("{:?}", cache.value);let x = 123;let mut cache = Cacher::new(|x| -> i32 {x});cache.value(x);println!("{:?}", cache.value);
}struct Cacher<T, E>
whereT: Fn(E) -> E,E: Clone + Debug
{query: T,value: Option<E>,
}impl<T, E> Cacher<T, E>
whereT: Fn(E) -> E,E: Clone + Debug
{fn new(query: T) -> Self{Cacher { query, value: None}}fn value(&mut self, arg: E) -> E {match self.value.clone() {Some(v) => v,None => {let v = (self.query)(arg);self.value = Some(v.clone());v}}}
}

上面这段代码有以下几点需要注意。

  1. Cacher结构体有一个value字段，类型是Option<T>，同时Cacher还拥有一个value方法。（因此在rust里，set和get操作，就是给字段和方法起同一个名字，我的评价是不如C#）
  2. 给E的特征约束是Clone+Debug，这样无论对于什么类型，都可以进行复制和打印输出。
  3. 需要注意let v = (self.query)(arg)这行，前面的self.query必须用括号包括起来，否则会编译器会报错。
  4. 闭包捕获了String类型的x的时候，并没有导致所有权转移，（因为之后我们正常调用了cache.value(x)）需要知道这里发生了什么。

捕获引用或者移动所有权

闭包可以通过三种方式捕获作用域中的值，它们直接对应到函数获取参数的三种方式：不可变借用，可变借用和获取所有权。闭包会根据函数体中如何使用被捕获的值决定用哪种方式捕获。这点非常抽象，不如C++的lambda表达式简单易懂。

  1. 以不可变引用方式捕获

    fn main() {let mut x = "Hello".to_string();let lambda = || println!("{}", x);      // 在闭包对变量x的操作是只读，因此rust会使用不可变引用方式来捕获lambda();  // 使用闭包x.push_str(", World!");println!("{}", x);
}

    在来看一个例子：

    fn main() {let mut x = "Hello".to_string();let lambda = || println!("{}", x);      // 在闭包对变量x的操作是只读，因此rust会使用不可变引用方式来捕获lambda();   // 使用闭包，（其中存在x的不可变引用）x.push_str(", World!");println!("{}", x);      lambda();   // 再次调用lambda
}

    这个例子无法通过编译，这是因为编译器检查到在同一作用域内，既有可变引用，又有不可变引用。最后一次调用lambda的时候，其中存在x的不可变引用，而之前的x.push_str又是一个可变引用。具体的报错如下所示： 在这里插入图片描述 报错中很直接的指出既有mutable又有immutable。
    2. 以可变引用方式捕获

    fn main() {let mut x = "Hello".to_string();let mut lambda = || x.push_str(", World");lambda();x.push_str("-- from zhangsan");println!("{}", x);
}

    这个例子中，我们在闭包中对捕获的x做了修改，因此rust会以可变引用的方式捕获，需要注意的是lambda必须是可变的才行。另外我们在调用了lambda之后，又使用了push_str来修改x，编译成功通过。这是因为rust的编译器检测到lambda不再使用，直接被drop掉了。因此当前作用域内只有一个可变引用，而不是两个可变引用。我们可以通过下面的例子来证实这一点。

    fn main() {
let mut x = "Hello".to_string();
let mut lambda = || x.push_str(", World!");
lambda();
x.push_str("-- from zhangsan");
lambda();   // 再次调用lambda
}

    这段代码无法通过编译，原因是同一作用域内存在两个可变引用，这是rust不允许的。具体错误如下图所示。
    在这里插入图片描述

  2. 以转移所有权方式捕获

    下面这个例子用来展示转移所有权方式捕获。

    fn func(s: String) {println!("{s}");
}fn main() {let x = "Hello".to_string();let lambda = || func(x);lambda();
}

    我们在闭包中调用了func函数，将x的所有权转移到了func函数中。x随着func函数调用结束而释放。我们来使用一个例子来证实。

    fn func(s: String) {println!("{s}");
}fn main() {let x = "Hello".to_string();let lambda = || func(x);lambda();println!("{}", x);
}

编译报错信息如下所示：
在这里插入图片描述
错误显示我们借用了一个moved之后的值。因此会失败。同时上面这种方式也会导致只能调用一次lambda闭包。例如：

fn func(s: String) {println!("{s}");
}fn main() {let x = "Hello".to_string();let lambda = || func(x);lambda();lambda();	// ERROR
}

在这里插入图片描述
同时注意到编译器提示我们this value implements FnOnce, which causes it to be moved when called。说我们的lambda实现了FnOnce trait，在调用时会发生所有权移动。因为随着x的所有权被转移到func函数中，它已经随着第一次func函数调用而被释放。如果我们想要既能捕获环境中变量的所有权，又能多次调用，需要使用关键字move，它将环境中的变量所有权转移到闭包中。在将闭包传递到一个新的线程时这个技巧很有用，它可以移动数据所有权给新线程。例如：

fn func(s: &String) {	// 传递String类型的引用println!("{s}");
}fn main() {let x = "Hello".to_string();let lambda = move || func(&x);		// movelambda();lambda();	// 第二次调用lambda
}

这样，我们的第二次调用lambda就是成功的。为了验证x确实被移动走了，我们在调用一次lambda之后增加一行打印。来看看程序执行是否出错，如果出错那就证明x被移走了，否则x没有被移走。

fn func(s: &String) {println!("{s}");
}fn main() {let x = "Hello".to_string();let lambda = move || {func(&x)};lambda();println!("{}", x);		// ERROR		value borrowed here after movelambda();
}

程序执行报错，表明x确实被移走了。因此我们无法在println!中打印这个x。不过此时还有一个疑问，那就是x可以被转移到闭包内，它的生命周期和闭包本身是一样的，而闭包的生命周期就是它最后一次被调用的时候。

Fn trait

闭包捕获和处理环境中的值的方式影响闭包实现的 trait。Trait 是函数和结构体指定它们能用的闭包的类型的方式。取决于闭包体如何处理值，闭包自动、渐进地实现一个、两个或三个 Fn trait。

  1. FnOnce 适用于能被调用一次的闭包，所有闭包都至少实现了这个 trait，因为所有闭包都能被调用。它只能被调用一次，在第一次调用后被释放。
  2. FnMut 适用于不会将捕获的值移出闭包体的闭包，但它可能会修改被捕获的值。这类闭包可以被调用多次。
  3. Fn 适用于既不将被捕获的值移出闭包体也不修改被捕获的值的闭包，当然也包括不从环境中捕获值的闭包。这类闭包可以被调用多次而不改变它们的环境，这在会多次并发调用闭包的场景中十分重要。

函数也可以实现所有的三种 Fn traits。如果我们要做的事情不需要从环境中捕获值，则可以在需要某种实现了 Fn trait 的东西时使用函数而不是闭包。下面的例子展示了Fn trait的用法，并且这个例子中充满了陷阱。

struct Human<T>where T: FnOnce() -> String
{name: T
}impl<T> Human<T>where T: FnOnce() -> String
{fn new(name: T) -> Self {Human { name }}fn get_name(self) -> String{(self.name)()}
}fn main() {let name = "zhangsan".to_string();let lambda = || name;let h = Human::new(lambda);println!("{}", h.get_name());
}

首先，由于FnOnce的trait约束，lambda闭包将以转移所有权的方式捕获环境中的name，并且闭包第一次调用后，被释放；
其次，get_name中的参数是self，意味着将h的所有权转移到get_name中，随着get_name调用结束，h被释放。我们再来看一个例子：

fn main() {let s = "Hello".to_string();let update_string = || println!("{}",s);exec(update_string);
}fn exec<F: FnOnce()>(f: F)  {f();
}

这个例子中的，闭包以不可变引用的方式捕获了s，exec的参数f要求的约束是FnOnce。因此f只能被调用一次，如果在exec中多次调用f，那么编译器会提示你加上Copy trait。

实际上，一个闭包并不仅仅实现某一种 Fn 特征，规则如下：

  1. 所有的闭包都自动实现了 FnOnce 特征，因此任何一个闭包都至少可以被调用一次
  2. 没有移出所捕获变量的所有权的闭包自动实现了 FnMut 特征
  3. 不需要对捕获变量进行改变的闭包自动实现了 Fn 特征

下面这个例子很好的说明这一点。

fn main() {let s = "Hello".to_string();let update_string =  || println!("{}",s);exec(update_string);exec1(update_string);exec2(update_string);}fn exec<F: FnOnce()>(f: F)  {f()
}fn exec1<F: FnMut()>(mut f: F)  {f()
}fn exec2<F: Fn()>(f: F)  {f()
}

虽然，闭包只是对 s 进行了不可变借用，实际上，它可以适用于任何一种 Fn 特征：三个 exec 函数说明了一切。一个闭包实现了哪种 Fn 特征取决于该闭包如何使用被捕获的变量。下面是三个Fn trait的简化版源码。

pub trait Fn<Args> : FnMut<Args> {extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}pub trait FnMut<Args> : FnOnce<Args> {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 的前提是实现 FnMut，FnMut 的前提是实现 FnOnce，因此要实现 Fn 就要同时实现 FnMut 和 FnOnce。从源码中还能看出一点：Fn 获取 &self，FnMut 获取 &mut self，而 FnOnce 获取 self。 在实际项目中，建议先使用 Fn 特征，然后编译器会告诉你正误以及该如何选择。

参考资料

  1. Rust语言圣经
  2. Rust 程序设计语言

http://www.ppmy.cn/news/44947.html

相关文章

【前端之旅】Vue入门笔记

【前端之旅】Vue入门笔记

一名软件工程专业学生的前端之旅，记录自己对三件套（HTML、CSS、JavaScript）、Jquery、Ajax、Axios、Bootstrap、Node.js、Vue、小程序开发（Uniapp）以及各种UI组件库、前端框架的学习。 【前端之旅】Web基础与开发工具 【前端之旅】手把手教你安装VS Code并附上超实用插件…
阅读更多...
nvm安装及使用

nvm安装及使用

nvm是一个node的版本管理工具。 nvm-windows下载 1、安装 首先要卸载电脑上已经有的node版本&#xff0c;注意需要卸载干净&#xff0c;再安装nvm 一路 next 安装就可以了。 安装成功后&#xff0c;以管理员身份运行&#xff08;很重要&#xff01;&#xff01;&#xff01;…
阅读更多...
安装elasticsearch

安装elasticsearch

1.部署单点es 因为我们还需要部署kibana容器&#xff0c;因此需要让es和kibana容器互联。这里先创建一个网络&#xff1a; docker network create es-net运行docker命令&#xff0c;部署单点es&#xff1a; docker run -d \--name es \-e "ES_JAVA_OPTS-Xms512m -Xmx51…
阅读更多...
排序算法（二）

排序算法（二）

三、桶排序 先看定义&#xff1a; 桶排序会进行两次排序&#xff0c;一次将所有元素分配到不同的桶中&#xff0c;一次针对每个桶排序或再次排序所有元素。 练习题&#xff1a; 1&#xff09; 力扣https://leetcode.cn/problems/top-k-frequent-elements/这道题就是非常典型…
阅读更多...
Spring Cloud微服务网关Zuul过滤链和整合OAuth2+JWT入门实战

Spring Cloud微服务网关Zuul过滤链和整合OAuth2+JWT入门实战

一、Spring Cloud Zuul 过滤链 1.1 工作原理 Zuul的核心逻辑是由一系列的Filter来实现的&#xff0c;他们能够在进行HTTP请求或者相应的时候执行相关操作。Zuul Filter的主要特性有一下几点&#xff1a; Filter的类型&#xff1a;Filter的类型决定了它在Filter链中的执行顺序…
阅读更多...
信号处理流程

信号处理流程

1.降噪处理 我们在录制音频数据的同时&#xff0c;大量噪声都会掺杂进来&#xff0c;不同环境和情境下产生的噪声也不尽相同&#xff0c;噪声信号中的无规则波纹信息影响了声学信号所固有的声学特性&#xff0c;使得待分析的声音信号质量下降&#xff0c;并且噪声对声音识别系统…
阅读更多...
【《C Primer Plus》读书笔记】第16章：C预处理器和C库

【《C Primer Plus》读书笔记】第16章：C预处理器和C库

【《C Primer Plus》读书笔记】第16章&#xff1a;C预处理器和C库 16.1 翻译程序的第一步16.2 明示常量&#xff1a;#define16.2.1 记号16.2.2 重定义常量 16.3 在#define中使用参数16.3.1 用宏参数创建字符串&#xff1a;#运算符16.3.2 预处理器黏合剂&#xff1a;##运算符16.…
阅读更多...
【瑞吉外卖】002 -- 后台登录功能开发

【瑞吉外卖】002 -- 后台登录功能开发

本文章为对 黑马程序员Java项目实战《瑞吉外卖》的学习记录 目录 一、需求分析 1、页面原型展示 2、登录页面展示 3、查看登录请求信息 4、数据模型 二、代码开发 1、创建实体类Employee&#xff0c;和employee表进行映射 2、创建包结构&#xff1a;&#xff08;Controller、Se…
阅读更多...
最新文章

Copyright @ 2022~2023