Rust- 闭包

这篇具有很好参考价值的文章主要介绍了Rust- 闭包。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

A closure in Rust is an anonymous function you can save in a variable or pass as an argument to another function. You can create the closure using a lightweight syntax and access variables from the scope in which it’s defined.

Here’s an example of a closure that increases a number by one:

let plus_one = |x: i32| x + 1;

let a = 5;
println!("{}", plus_one(a)); // Outputs 6

In this example, plus_one is a closure that takes one argument x and returns x + 1.

Closures in Rust are similar to lambdas in other languages, but they have some specific behaviors and capabilities.

  • Capture Environment: Closures have the ability to capture values from the scope in which they’re defined. Here’s an example:

    let num = 5;
    let plus_num = |x: i32| x + num;
    println!("{}", plus_num(10)); // Outputs 15
    

    Here, plus_num captures the value of num from the surrounding environment.

  • Flexible Input Types: Unlike functions, closures don’t require you to annotate the types of the input parameters. However, you can if you want to, and sometimes doing so can increase clarity.

  • Three Flavors of Closures: Closures in Rust come in three forms, which differ in how they capture variables from the surrounding scope: Fn, FnMut, and FnOnce. The type is chosen by the compiler based on how the closure uses variables from the environment.

    • FnOnce consumes the variables it captures from its enclosing scope, known as the “once” because it can’t take ownership more than once.
    • FnMut can change the environment because it mutably borrows values.
    • Fn borrows values from the environment immutably.

Let’s start with an overview of each:

  1. FnOnce captures variables and moves them into the closure when it is defined. It can consume those variables when the closure is called. FnOnce closures can’t be called more than once in some contexts without duplication.

  2. FnMut can mutate and also consume variables from the environment in which it is defined.

  3. Fn borrows variables from the environment immutably.

Now, let’s have a look at some examples for each type:

// Example of FnOnce
let x = "hello".to_string();
let consume_x = move || println!("{}", x);
consume_x(); // "hello"
// consume_x(); This won't compile because `x` has been moved into the closure

// Example of FnMut
let mut y = "hello".to_string();
let mut append_world = || y.push_str(" world");
append_world();
println!("{}", y); // "hello world"

// Example of Fn
let z = "hello".to_string();
let print_z = || println!("{}", z);
print_z();
print_z(); // We can call this as many times as we want.

① In the first example, the closure takes ownership of x (indicated by the move keyword), so it’s a FnOnce.

② In the second example, the closure mutably borrows y, so it’s a FnMut.

③ In the third example, the closure immutably borrows z, so it’s a Fn.

Rust chooses how to capture variables on the fly without any annotation required. The move keyword is used to force the closure to take ownership of the values it uses.

Closures are a fundamental feature for many Rust idioms. They are used extensively in iterator adapters, threading, and many other situations.文章来源地址https://www.toymoban.com/news/detail-620554.html

fn main() {
    /*
       || 代替 ()将输入参数括起来
       函数体界定符是{},对于单个表达式是可选的,其他情况必须加上。
       有能力捕获外部环境的变量。

       |参数列表| {
           业务逻辑
       }

       || {
           业务逻辑
       }

       闭包可以赋值一个变量。
    */

    let double = |x| {x * 2};
    let add = |a, b| {a + b};

    let x = add(2, 4);
    println!("{}", x);          // 6

    let y = double(5);
    println!("{}", y);          // 10

    let v = 3;
    let add2 = |x| {v + x};
    println!("{}", add2(4));    // 7

    /*
       闭包,可以在没有标注的情况下运行。可移动(move), 可借用(borrow), 
       闭包可以通过
            引用 &T
            可变引用 &mut T
            值 T
       捕获

       1. 闭包是一个在函数内创建立即调用的另外一个函数。
       2. 闭包是一个匿名函数
       3. 闭包虽然没有函数名,但可以把整个闭包赋值一个变量,
          通过该变量来完成闭包的调用
       4. 闭包不用声明返回值,但可以有返回值。并且使用最后一条语句的执行结果
          作为返回值,闭包的返回值也可以给变量。
       5. 闭包也称之为内联函数,可以访问外层函数里的变量。
     */
}

fn main() {
    let add = |x, y| x + y;
    let result = add(3, 4);
    println!("{}", result); // 7

    receives_closure(add); // // 闭包作为参数执行结果 => 8

    let y = 2;
    receives_closure2(|x| x + y); // closure(1) => 3

    let y = 3;
    receives_closure2(|x| x + y); // closure(1) => 4

    let closure = returns_closure();
    println!("返回闭包 => {}", closure(1)); // 返回闭包 => 7

    let result = do1(add, 5);
    println!("result(1) => {}", result(1)); // result(1) => 6

    let result = do2(add, 5);
    println!("result(2) => {}", result(2)); // result(2) => 7
}

fn do2<F, X, Y, Z>(f: F, x: X) -> impl Fn(Y) -> Z
where
    F: Fn(X, Y) -> Z,
    X: Copy,
{
    move |y| f(x, y)
}

// 参数和返回值都有闭包
fn do1<F>(f: F, x: i32) -> impl Fn(i32) -> i32
where
    F: Fn(i32, i32) -> i32,
{
    move |y| f(x, y)
}

// 返回闭包
fn returns_closure() -> impl Fn(i32) -> i32 {
    |x| x + 6
}

// 闭包作为参数
fn receives_closure<F>(closure: F)
where
    F: Fn(i32, i32) -> i32,
{
    let result = closure(3, 5);
    println!("闭包作为参数执行结果 => {}", result)
}

// 闭包捕获变量
fn receives_closure2<F>(closure: F)
where
    F: Fn(i32) -> i32,
{
    let result = closure(1);
    println!("closure(1) => {}", result);
}

到了这里,关于Rust- 闭包的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Rust】Rust学习 第十三章Rust 中的函数式语言功能:迭代器与闭包

    Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是  函数式编程 ( functional programming )。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。 更具体的,我们将要涉及: 闭包 ( Closures ),一个可以储

    2024年02月12日
    浏览(53)
  • rust 自动化测试、迭代器与闭包、智能指针、无畏并发

    编写测试可以让我们的代码在后续迭代过程中不出现功能性缺陷问题;理解迭代器、闭包的函数式编程特性; BoxT 智能指针在堆上存储数据, RcT 智能指针开启多所有权模式等;理解并发,如何安全的使用线程,共享数据。 编写测试以方便我们在后续的迭代过程中,不会改坏

    2024年02月16日
    浏览(40)
  • 【跟小嘉学 Rust 编程】十三、函数式语言特性:迭代器和闭包

    【跟小嘉学 Rust 编程】一、Rust 编程基础 【跟小嘉学 Rust 编程】二、Rust 包管理工具使用 【跟小嘉学 Rust 编程】三、Rust 的基本程序概念 【跟小嘉学 Rust 编程】四、理解 Rust 的所有权概念 【跟小嘉学 Rust 编程】五、使用结构体关联结构化数据 【跟小嘉学 Rust 编程】六、枚举

    2024年02月11日
    浏览(60)
  • Rust编程语言入门之函数式语言特性:-迭代器和闭包

    闭包(closures) 迭代器(iterators) 优化改善 12 章的实例项目 讨论闭包和迭代器的运行时性能 闭包:可以捕获其所在环境的匿名函数。 闭包: 是匿名函数 保存为变量、作为参数 可在一个地方创建闭包,然后在另一个上下文中调用闭包来完成运算 可从其定义的作用域捕获值

    2023年04月08日
    浏览(46)
  • 研读Rust圣经解析——Rust learn-15(unsafe Rust )

    Rust 还隐藏有第二种语言,它不会强制执行这类内存安全保证:这被称为 不安全 Rust(unsafe Rust) 不安全 Rust 之所以存在,是因为静态分析本质上是保守的。当编译器尝试确定一段代码是否支持某个保证时,拒绝一些合法的程序比接受无效的程序要好一些。这必然意味着有时

    2024年02月01日
    浏览(36)
  • 【Rust】Rust学习 第十七章Rust 的面向对象特性

    面向对象编程(Object-Oriented Programming,OOP)是一种模式化编程方式。对象(Object)来源于 20 世纪 60 年代的 Simula 编程语言。这些对象影响了 Alan Kay 的编程架构中对象之间的消息传递。他在 1967 年创造了  面向对象编程  这个术语来描述这种架构。关于 OOP 是什么有很多相互矛

    2024年02月11日
    浏览(48)
  • 【Rust教程 | 基础系列1 | Rust初相识】Rust简介与环境配置

    Rust是一种系统编程语言,专注于速度、内存安全和并行性。它的设计目标是提供一种能够实现高性能系统的语言,同时保证内存安全和线程安全。 本篇教程的目标是通过融合理论与实践,帮助读者更快速、更有效地学习 Rust,并解决在学习过程中可能遇到的挑战。这些内容也

    2024年02月15日
    浏览(65)
  • 【Rust学习】安装Rust环境

    本笔记为了记录学习Rust过程,内容如有错误请大佬指教 使用IDE:vs code 参考教程:菜鸟教程链接: 菜鸟教程链接: 因为我已经安装过VSCode了,所以VSCode的安装方法在此处就不多介绍了,接下来就是安装Rust的编译工具。 Rust 编译工具 可以点击跳转下载Rust 编译工具 新建文件夹,

    2024年01月17日
    浏览(63)
  • 【Rust 基础篇】Rust 封装

    在 Rust 中,封装是一种面向对象编程的重要概念,它允许将数据和相关的方法组合在一起,形成一个独立的单元。通过封装,我们可以隐藏数据的实现细节,只暴露需要对外部使用的接口,从而提高代码的可维护性和安全性。本篇博客将详细介绍 Rust 中封装的概念,包含代码

    2024年02月16日
    浏览(70)
  • Rust 性能优化 : Rust 性能优化技巧,提升 Rust 程序的执行效率和资源利用率 The Rust Performance

    作者:禅与计算机程序设计艺术 在过去的几年中,随着编程语言的快速发展,编程人员已经逐渐从依赖编译型语言转向了使用解释型语言。相对于编译型语言来说,解释型语言具有更快的执行速度,在某些情况下甚至可以实现接近编译器的运行时效率。但是另一方面,这些语

    2024年02月07日
    浏览(101)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包