闭包 (Closures) 是 Rust 中一种特殊的匿名函数，它们能够捕获其定义环境中的变量。与普通函数不同，闭包可以访问自身作用域之外的变量，即使这些变量在闭包被调用时已经脱离了原始作用域。这种能力使得闭包在 Rust 中成为实现回调、迭代器适配器、以及其他高度灵活和富有表现力的编程模式的关键工具。Rust 的闭包不仅功能强大，而且在设计上充分考虑了所有权和借用规则，确保了内存安全。

核心思想：

  • 匿名函数：没有名称，可以作为参数传递或赋值给变量。
  • 捕获环境：能够访问并使用其定义作用域中的变量。
  • 所有权和借用：Rust 闭包捕获变量的方式（借用、可变借用、所有权）严格遵循 Rust 的所有权规则，确保内存安全。
  • 灵活强大：广泛应用于迭代器、回调函数、并发编程等场景。

一、为什么需要闭包？

在编程中，我们经常需要处理一些需要“携带上下文”的逻辑，或者需要定义一些简单、一次性的函数。此时，闭包的优势就显现出来了：

  1. 代码简洁性：对于一些简单的、只使用一两次的逻辑，使用闭包可以避免定义一个完整的命名函数，使代码更加紧凑和可读。例如，在迭代器链中，闭包作为 map、filter 等方法的参数。
  2. 携带上下文：闭包能够捕获其所在环境的变量，这意味着它们可以访问和操作这些变量，而无需将它们作为显式参数传递。这在实现回调函数或需要记住某些状态的逻辑时非常有用。
  3. 函数式编程：闭包是函数式编程范式的重要组成部分，使得 Rust 能够更好地支持高阶函数，例如将函数作为参数传递给其他函数。
  4. 提高灵活性：闭包可以被赋值给变量，也可以作为返回值从函数中返回，这为程序的动态行为提供了更大的灵活性。
  5. 延迟执行：闭包通常不会在定义时立即执行，而是在需要时才被调用，这在事件处理、异步编程等场景中非常有用。

二、闭包的语法

Rust 闭包的语法简洁明了，与函数定义类似，但存在一些关键差异。

2.1 基本语法

1
2
3
4
|param1, param2, ...| -> return_type {
    // 闭包体
    // ...
}
  • |param1, param2, ...|：参数列表，包裹在竖线 | 之间。如果闭包没有参数，则写 ||。
  • -> return_type：可选的返回类型声明。如果闭包体只有一行表达式，或者返回类型可以被推断出来，则可以省略。
  • { ... }：闭包体。如果闭包体只有一行表达式，可以省略花括号。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 1. 无参数，无返回值的闭包
let greet = || {
    println!("Hello from a closure!");
};
greet(); // 调用闭包

// 2. 有参数，有返回值的闭包 (Rust 会自动推断类型)
let add_one = |x: i32| x + 1;
println!("1 + 1 = {}", add_one(1)); // 输出: 1 + 1 = 2

// 3. 多行闭包体，明确返回类型
let calculate_sum_and_product = |a: i32, b: i32| -> (i32, i32) {
    let sum = a + b;
    let product = a * b;
    (sum, product) // 不需要 return 关键字
};
let (sum, product) = calculate_sum_and_product(3, 4);
println!("Sum: {}, Product: {}", sum, product); // 输出: Sum: 7, Product: 12

三、闭包捕获环境变量的方式

这是闭包最核心的特性。Rust 闭包捕获环境中的变量有三种主要方式，它们对应于三种不同的 Fn* trait：

3.1 借用 (&T) - Fn Trait

闭包以不可变借用的方式捕获环境中的变量。这意味着闭包可以读取变量，但不能修改它，并且在闭包存在期间，原始变量不能被可变借用或移动。

  • 特点：非独占访问，可以多次调用，可以安全的实现 Copy 或 Clone。
  • 对应 Trait：Fn。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
let text = String::from("hello");

// 闭包以不可变借用方式捕获 `text`
let printer = || {
    println!("{}", text); // 借用 `text`
};

printer(); // 多次调用没问题
printer();

drop(text); // 错误：`text` 在 `printer` 借用期间不能被移动

// 修复：在使用完闭包后才 drop `text`
let text = String::from("hello");
let printer = || {
    println!("{}", text);
};
printer();
printer();
// `text` 可以在这里被 drop

3.2 可变借用 (&mut T) - FnMut Trait

闭包以可变借用的方式捕获环境中的变量。这意味着闭包可以读取和修改变量，但在闭包存在期间，原始变量不能被其他方式借用或移动。

  • 特点：独占可变访问，可以被多次调用以修改状态。
  • 对应 Trait：FnMut。
1
2
3
4
5
6
7
8
9
10
11
12
let mut counter = 0;

// 闭包以可变借用方式捕获 `counter`
let mut incrementer = || {
    counter += 1; // 可变借用 `counter`
};

incrementer();
incrementer();
println!("Counter: {}", counter); // 输出: Counter: 2

// drop(counter); // 错误：`counter` 在 `incrementer` 借用期间不能被移动

3.3 取得所有权 (T) - FnOnce Trait

闭包通过移动 (move) 方式获取环境中的变量的所有权。这意味着变量在被闭包捕获后，就归闭包所有，原始作用域将无法再访问该变量。这种类型的闭包只能被调用一次，因为变量的所有权已经被转移到闭包内部。

  • 特点：独占所有权，只能调用一次。
  • 对应 Trait：FnOnce。
1
2
3
4
5
6
7
8
9
10
11
12
13
let data = vec![1, 2, 3];

// 使用 `move` 关键字强制闭包取得 `data` 的所有权
let processor = move || {
    println!("Processing data: {:?}", data);
    data.len() // `data` 在这里被消费
};

let length = processor(); // 第一次调用，`data` 的所有权转移到闭包内部并被使用
println!("Length: {}", length);

// processor(); // 错误：闭包只能被调用一次，因为 `data` 已经被移动并消费
// println!("Original data: {:?}", data); // 错误：`data` 在这里不再有效

何时使用 move 关键字？

  • 强制所有权转移：当闭包需要获取被捕获变量的所有权时（例如将其存储起来），需要使用 move。
  • 线程边界：在使用并发时，为了将数据安全地从一个线程传递到另一个线程，通常需要 move 闭包及其捕获的变量。
  • 避免生命周期问题：当闭包的生命周期可能比其捕获的引用变量更长时，move 可以避免 Dangling Reference 问题。

四、闭包 Trait：Fn, FnMut, FnOnce

Rust 通过三个特殊的 Trait 来实现闭包的捕获行为：

  • Fn：表示闭包会以不可变借用 (&T) 的方式捕获变量，可以被多次调用，并且可以安全地在多个线程间共享（如果其捕获的变量也是 Sync）。
  • FnMut：表示闭包会以可变借用 (&mut T) 的方式捕获变量，可以被多次调用，并修改捕获变量。
  • FnOnce：表示闭包会以取得所有权 (T) 的方式捕获变量，因此只能被调用一次。

这三个 Trait 构成了继承关系：Fn 继承自 FnMut，FnMut 继承自 FnOnce。这意味着：

  • 任何 Fn 闭包都可以作为 FnMut 闭包使用。
  • 任何 FnMut 闭包都可以作为 FnOnce 闭包使用。
  • 但反之不成立。

在 Rust 中，函数参数接受闭包时通常会使用这些 Trait 作为泛型约束。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 接受 FnOnce 闭包：可以消费捕获的变量，只能调用一次
fn call_once<F>(f: F)
where
    F: FnOnce(),
{
    f();
}

// 接受 FnMut 闭包：可以修改捕获的变量，可以多次调用
fn call_mut<F>(mut f: F) // 注意这里 `f` 需要是 `mut`
where
    F: FnMut(),
{
    f();
    f();
}

// 接受 Fn 闭包：只不可变借用捕获的变量，可以多次调用
fn call_fn<F>(f: F)
where
    F: Fn(),
{
    f();
    f();
}

let x = String::from("hello");
let mut y = 0;

call_once(move || {
    println!("Call once: {}", x); // x被移动
});
// println!("{}", x); // 错误：x已被移动

call_mut(|| {
    y += 1; // y被可变借用
});
println!("Y after call_mut: {}", y); // 输出: Y after call_mut: 2

call_fn(|| {
    println!("This is a Fn closure");
});

Rust 编译器会根据闭包如何使用其捕获的变量，自动推断出最不严格 (即最通用) 的 Fn* trait。例如，一个只打印捕获变量的闭包会被推断为 Fn。但如果你使用了 move 关键字，它会被强制推断为 FnOnce。

五、闭包在实际中的应用

闭包在 Rust 中有极其广泛的应用：

5.1 迭代器适配器

这是闭包最常见的用途之一。Iterator Trait 的许多方法（如 map, filter, for_each, find, any, all 等）都接受闭包作为参数，以自定义迭代行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
let numbers = vec![1, 2, 3, 4, 5];

// 使用 `filter` 闭包过滤偶数
let even_numbers: Vec<i32> = numbers
    .iter()
    .filter(|&x| x % 2 == 0) // |&x| 是为了解引用，方便操作
    .cloned() // 因为filter返回的是引用，需要克隆或collect到 Vec<&i32>
    .collect();
println!("Even numbers: {:?}", even_numbers); // 输出: Even numbers: [2, 4]

// 使用 `map` 闭包将每个数字加倍
let doubled_numbers: Vec<i32> = numbers
    .iter()
    .map(|x| x * 2)
    .collect();
println!("Doubled numbers: {:?}", doubled_numbers); // 输出: Doubled numbers: [2, 4, 6, 8, 10]

let mut accumulated_sum = 0;
// 使用 `for_each` 闭包，可变借用 `accumulated_sum`
numbers.iter().for_each(|x| {
    accumulated_sum += x;
});
println!("Accumulated sum: {}", accumulated_sum); // 输出: Accumulated sum: 15

5.2 回调函数

在事件处理、异步编程、GUI 库等场景中，闭包常被用作回调函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 模拟一个需要回调的函数
fn do_something_async<F>(callback: F)
where
    F: Fn(i32) + Send + 'static, // 需要 Send + 'static 来跨线程
{
    std::thread::spawn(move || {
        // 模拟一些工作
        std::thread::sleep(std::time::Duration::from_secs(1));
        let result = 42;
        callback(result); // 调用回调
    });
}

let mut data_received = false;
let message = String::from("Received result:");

do_something_async(move |result| { // 使用 move 捕获 `message` 和 `data_received`
    println!("{} {}", message, result);
    data_received = true; // 修改捕获的变量
});

// 主线程做一些其他事情
println!("Main thread continues...");
std::thread::sleep(std::time::Duration::from_secs(2));
println!("Data received status: {}", data_received); // 输出: Data received status: true

5.3 线程和并发

在 Rust 的并发编程中，闭包通常与 thread::spawn 结合使用，利用 move 关键字将数据的所有权安全地转移到新线程。

1
2
3
4
5
6
7
8
9
10
11
use std::thread;

let v = vec![1, 2, 3];

// 使用 `move` 关键字将 `v` 的所有权转移给闭包，进而转移给新线程
let handle = thread::spawn(move || {
    println!("Here's a vector in a new thread: {:?}", v);
});

handle.join().unwrap();
// println!("{:?}", v); // 错误：v已在主线程中被移动

5.4 缓存 (Memoization)

通过闭包捕获状态可以实现简单的缓存机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
struct Cacher<T>
where
    T: Fn(u32) -> u32,
{
    calculation: T,
    value: Option<u32>,
}

impl<T> Cacher<T>
where
    T: Fn(u32) -> u32,
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }

    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}

let mut expensive_result = Cacher::new(|num| {
    println!("Calculating slowly...");
    std::thread::sleep(std::time::Duration::from_secs(2));
    num
});

expensive_result.value(10); // 第一次调用，会计算
expensive_result.value(10); // 第二次调用，直接返回缓存值，不会重新计算

六、闭包的性能与开销

Rust 闭包的性能通常与手写函数相当，甚至可能更好，因为：

  • 编译期优化：Rust 编译器对闭包进行了高度优化。它知道闭包的精确类型（每个闭包都有一个唯一的匿名类型），并可以对捕获变量进行静态分析。
  • 零开销抽象：闭包通常不会引入额外的运行时开销。编译器会将闭包和其捕获的环境尽可能地内联到调用点，或者以静态分派 (static dispatch) 的方式处理，避免了动态分派 (dynamic dispatch) 的性能成本。
  • 内存安全：Rust 的所有权和借用规则确保了闭包即使捕获了变量，也不会发生数据竞争或 Dangling Reference 等内存安全问题。

然而，如果将闭包作为 Trait Object (例如 Box<dyn Fn()>) 使用，可能会引入动态分派的开销，但这是为了获得运行时多态性所必需的。

七、总结

Rust 闭包是该语言中一个强大且富有表现力的特性。它们是匿名的函数，能够安全、高效地捕获其定义环境中的变量。通过理解 Fn、FnMut 和 FnOnce 这三个 Trait，以及 move 关键字的作用，开发者可以精确控制闭包捕获变量的方式，从而编写出内存安全且高性能的代码。

闭包在 Rust 的很多核心库和惯用模式中都扮演着关键角色，尤其是在处理迭代器、并发编程和回调函数时。熟练掌握闭包的使用，是成为一名高效 Rust 程序员的重要一步。