Rust语言闭包入门：定义、特点及实际应用示例

创作时间:

作者:

@小白创作中心

Rust语言闭包入门：定义、特点及实际应用示例

引用

CSDN

https://m.blog.csdn.net/weixin_71793197/article/details/145172608

Rust语言在设计过程中受到了许多语言的启发，其中函数式编程对Rust产生了显著的影响。函数式编程通常包括将函数作为值传递给参数、从其他函数返回它们、将它们分配给变量以供以后执行等特性。在本章中，我们将讨论Rust的一些特性，这些特性与许多语言中通常称为函数式的特性相似，包括闭包、迭代器以及使用闭包和迭代器改进I/O项目等。

什么是闭包（closure）

一句话概括：闭包是可以捕获其所在环境的匿名函数。

闭包具有以下特点：

闭包是匿名函数
这个匿名函数可以保存为变量，或是作为参数传给另一个函数，还可以作为另外一个函数的返回值
可以在一个地方创建闭包，然后在另一个上下文中调用闭包来完成运算
闭包可以从其定义的作用域内捕获值

闭包的例子

为了更好地演示闭包的功能，这里举一个例子：做一个程序，根据人的身体指数等因素生成自定义的运动计划。这个程序的算法逻辑并不是重点，重点是算法在计算过程中会花费几秒的时间。我们的目标是不让用户发生不必要的等待。具体来说就是仅在必要的时候才调用该算法，而且只调用一次。

看下代码：

use std::thread;
use std::time::Duration;

fn main() {
    let simulated_user_specified_value = 10;
    let simulated_random_number = 7;
    
    generate_workout(
        simulated_user_specified_value,
        simulated_random_number,
    );
}

fn simulated_expensive_calculation(intensity: u32) -> u32 {
    println!("calculating slowly...");
    thread::sleep(Duration::from_secs(2));
    intensity
}

fn generate_workout(intensity: u32, random_number: u32) {
    if intensity < 25 {
        println!("Today, do {} pushups!", simulated_expensive_calculation(intensity));
        println!("Next, do {} situps!", simulated_expensive_calculation(intensity));
    } else {
        if random_number == 3 {
            println!("Take a break today! Remember to stay hydrated!");
        } else {
            println!("Today, run for {} minutes!", simulated_expensive_calculation(intensity));
        }
    }
}

simulated_expensive_calculation这个函数就是模拟那个复杂的算法，thread::sleep函数是用来模拟等待算法计算完毕所需的时间。由于就是个演示，所以最后就把intensity（意思是用户指定的强度）这个参数直接返回了。
generate_workout有两个参数，一个intensity，表示用户指定的锻炼强度；还有一个random_number，表示一个随机数。其函数体的逻辑是：如果强度intensity小于25就打印"Today, do {} pushups!“和"Next, do {} situps!“两句话。问题来了，这两句话都要调用耗时比较长的simulated_expensive_calculation。如果强度大于等于25，而且随机数等于3，就打印"Take a break today! Remember to stay hydrated!”，不需要调用耗时的函数。如果随机数不等于3，打印"Today, run for {} minutes!”，要调用耗时的simulated_expensive_calculation函数。

这个函数目前的写法确实没问题，但是太耗时了。我们的目标是不让用户发生不必要的等待。具体来说就是仅在必要的时候才调用该算法，而且只调用一次。

首先来看generate_workout函数中强度intensity小于25的情况：

if intensity < 25 {
        println!("Today, do {} pushups!", simulated_expensive_calculation(intensity));
        println!("Next, do {} situps!", simulated_expensive_calculation(intensity));

会打印"Today, do {} pushups!"和"Next, do {} situps!"两句话。问题来了，这两句话都要调用耗时比较长的simulated_expensive_calculation。实际上我们只需要计算一次的结果，然后把这个结果用在两个输出里重复使用即可。

我们就来优化这一部分，只需要运行一次把结果存在一个变量里在输出时调用这个变量就可以避免重复调用simulated_expensive_calculation：

fn generate_workout(intensity: u32, random_number: u32) {
    let expensive_result = simulated_expensive_calculation(intensity);
    if intensity < 25 {
        println!("Today, do {} pushups!", expensive_result);
        println!("Next, do {} situps!", expensive_result);
    } else {
        if random_number == 3 {
            println!("Take a break today! Remember to stay hydrated!");
        } else {
            println!("Today, run for {} minutes!", expensive_result);
        }
    }
}

这里我顺便把强度intensity大于25但random_number不等于3的情况下的输出也替换为了存储算法结果的变量expensive_result。

但是这样也导致了另一个问题：

if random_number == 3 {
    println!("Take a break today! Remember to stay hydrated!");
}

这里并不需要调用复杂的函数，但是由于：

let expensive_result = simulated_expensive_calculation(intensity);

这句话是在函数开头就执行了，所以即使随机数为3时不需要调用算法函数，函数仍然会在开头调用算法函数消耗时间，这属于没有必要的调用。

这就是闭包的用武之地，把这段代码用闭包修改修改一下：

fn generate_workout(intensity: u32, random_number: u32) {
    let expensive_closure = |num| {
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    };
    if intensity < 25 {
        println!("Today, do {} pushups!", expensive_closure(intensity));
        println!("Next, do {} situps!", expensive_closure(intensity));
    } else {
        if random_number == 3 {
            println!("Take a break today! Remember to stay hydrated!");
        } else {
            println!("Today, run for {} minutes!", expensive_closure(intensity));
        }
    }
}

闭包是这部分：

let expensive_closure = |num| {
    println!("calculating slowly...");
    thread::sleep(Duration::from_secs(2));
    num
};

把闭包赋给了变量expensive_closure。
这个闭包需要有参数，把参数放在两个管道符||中间，这里只有一个参数num，就写|num|。如果有两个参数，就用逗号分开，比如|num1, num2|，如果不需要参数，就只写||即可。
这里的参数num不需要显式声明类型是因为下文的调用中传进去的参数intensity的类型为u32，Rust推断出num的类型为u32。
闭包的函数体写在{}中，写法与其它函数无异。这里我们要通过这个闭包实现调用算法函数相同的效果，所以函数体跟算法函数一样即可，这时候就可以把simulated_expensive_calculation这个函数删掉了
整个闭包的这部分只是定义了一个函数，没有执行。函数只有在遇到()才会执行，例如expensive_closure(intensity)。