Rust语言学习：闭包 - 好暖好温暖的博客

1342 字

7 分钟

Rust语言学习：闭包

2025-10-23

rust

/

闭包

/

fn

/

迭代器

闭包是一种可以捕获其环境中变量的匿名函数。它在 Rust 中被广泛用于函数式编程、迭代器处理和并发编程。

下面的示例代码将围绕一个衬衫库存Inventory结构展开，演示闭包在实际场景中的应用。

1
use std::time::Duration;
2
use std::thread;
3

4
#[derive(Debug, PartialEq, Copy, Clone)]
5
enum ShirtColor {
6
    Red,
7
    Blue,
8
}
9

10
// 库存，表示有多少件不同颜色的衬衫
11
struct Inventory {
12
    shirts: Vec<ShirtColor>,
13
}
14

15
impl Inventory {
16
    // 根据用户偏好选择衬衫颜色，如果没有偏好则选择库存最多的颜色
17
    fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
18
        // unwrap_or_else 在 user_preference 为 None 时调用闭包
19
        // 闭包返回值为T，即 most_stocked() 的返回值
20
        user_preference.unwrap_or_else(|| self.most_stocked())
21
    }
22

23
    fn most_stocked(&self) -> ShirtColor {
24
        let red_count = self
25
            .shirts
26
            .iter()
27
            .filter(|&&c| c == ShirtColor::Red)
28
            .count();
29
        let blue_count = self
30
            .shirts
31
            .iter()
32
            .filter(|&&c| c == ShirtColor::Blue)
33
            .count();
34
        if red_count >= blue_count {
35
            ShirtColor::Red
36
        } else {
37
            ShirtColor::Blue
38
        }
39
    }
40
}
41

42
fn main() {
43
    let store = Inventory {
44
        shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
45
    };
46

47
    let user_pref1 = Some(ShirtColor::Red);
48
    let giveaway1 = store.giveaway(user_pref1);
49
    println!(
50
        "User preference: {:?}, Given away: {:?}",
51
        user_pref1, giveaway1
52
    );
53

54
    let user_pref2 = None;
55
    let giveaway2 = store.giveaway(user_pref2);
56
    println!(
57
        "User preference: {:?}, Given away: {:?}",
58
        user_pref2, giveaway2
59
    );
60

61
    // ... 后续代码 ...
62
}

在 giveaway 方法中，unwrap_or_else 接受一个闭包 || self.most_stocked()。这个闭包没有参数（由 || 表示），并在被调用时执行 self.most_stocked()。

1. 闭包的类型推断与标注#

Rust 编译器通常可以为闭包推断参数和返回值的类型。

1
// ... main 函数中 ...
2

3
// 1. 为闭包的参数和返回值显式标注类型
4
let expensive_closure = |num: u32| -> u32 {
5
    println!("This is an expensive closure!");
6
    thread::sleep(Duration::from_secs(2));
7
    num
8
};
9
println!("打印闭包 {:?}", expensive_closure(32));
10

11
// 2. 编译器自动推断类型
12
// 必须要求闭包的参数类型在上下文中可以被推断出来
13
let example_closure = |x| x;
14
let s = example_closure(String::from("hello"));
15

16
// 类型一旦被推断为 String，就不能再传入其他类型
17
// let n = example_closure(5); // 这将导致编译错误

2. 捕获环境（借用与所有权）#

闭包的核心特性是它可以捕获其定义时所在作用域中的变量。捕获方式有三种：不可变借用、可变借用和取得所有权。

2.1. 不可变借用 (Fn)#

闭包默认以最轻量的方式（不可变借用）捕获变量。

1
// ... main 函数中 ...
2
let list = vec![1, 2, 3];
3
println!("Before defining closure: {:?}", list);
4

5
// 闭包不可变地借用了 list
6
let only_borrows = || println!("From closure: {:?}", list);
7

8
// 调用闭包
9
only_borrows();
10

11
// 闭包调用后，list 仍然可用
12
println!("After calling closure: {:?}", list);

2.2. 可变借用 (FnMut)#

如果闭包需要修改捕获的变量，它会进行可变借用。

1
// ... main 函数中 ...
2
let mut list2 = vec![1, 2, 3];
3
println!("Before defining closure: {:?}", list2);
4

5
// 闭包可变地借用了 list2
6
let mut borrows_mutably = || list2.push(7);
7

8
// 可变借用在闭包调用（borrows_mutably()）之前都有效
9
// 在此期间（闭包定义后到调用前）无法使用被借用的值
10
// println!("Before calling closure: {:?}", list2); // 错误：不能在可变借用期间再次借用
11

12
borrows_mutably(); // 调用闭包，可变借用在此处使用
13

14
// 调用闭包之后，可变借用结束，后续可以正常打印
15
println!("After calling closure: {:?}", list2);

2.3. 取得所有权 (FnOnce 与 `move`)#

使用 move 关键字可以强制闭包获取其使用的值（捕获的值）的所有权。这在并发编程中尤其重要，例如将变量传递给新线程。

1
// ... main 函数中 ...
2
let list3 = vec![1, 2, 3];
3
println!("Before defining closure: {:?}", list3);
4

5
// 在闭包定义前加 move，表示闭包取得 list3 的所有权
6
thread::spawn(move || println!("From thread: {:?}", list3))
7
    .join()
8
    .unwrap();
9

10
// list3 的所有权已被移动到线程中，主线程无法再访问
11
// println!("After thread: {:?}", list3); // 错误：value borrowed here after move

注意：新线程捕获主线程的值时，通常必须获取所有权（使用 move），否则可能在主线程结束后，新线程持有的引用变成悬垂引用。

3. 闭包的 Trait：`Fn`、`FnMut`、`FnOnce`#

Rust 根据闭包如何捕获和使用环境变量，自动为其实现一个或多个 Fn Trait：

Trait	捕获方式	描述
`FnOnce`	取得所有权	闭包必须被调用（消费）一次。所有闭包都至少实现了 `FnOnce`。
`FnMut`	可变借用	闭包可以修改捕获的变量，可以被调用多次。
`Fn`	不可变借用	闭包不能修改捕获的变量，可以被调用多次。

继承关系：Fn 继承自 FnMut，FnMut 继承自 FnOnce。

Option<T> 的 unwrap_or_else 方法的签名展示了 FnOnce 的应用：

1
// impl<T> Option<T> {
2
//     pub fn unwrap_or_else<F>(self, f: F) -> T
3
//     where
4
//         F: FnOnce() -> T, // 要求F实现FnOnce，表示闭包可以被调用一次
5
//     {
6
//         match self {
7
//             Some(val) => val,
8
//             None => f(), // 只有在None的情况下才调用闭包f
9
//         }
10
//     }
11
// }

4. `FnMut` 与 `sort_by_key` 示例#

sort_by_key 方法需要一个实现了 FnMut 的闭包，因为它在排序过程中可能需要多次调用闭包来获取键值。

1
#[derive(Debug)]
2
struct Rectangle {
3
    width: u32,
4
    height: u32,
5
}
6

7
// ... main 函数中 ...
8
let mut list_rect = [
9
    Rectangle { width: 10, height: 5 },
10
    Rectangle { width: 20, height: 10 },
11
    Rectangle { width: 30, height: 15 },
12
];
13

14
// 闭包 |r| r.width 实现了 FnMut (实际上也实现了 Fn)
15
list_rect.sort_by_key(|r| r.width);
16
println!("Sorted by width: {:?}", list_rect);
17

18
// --- 演示 FnMut ---
19
let mut sort_operations = vec![];
20
let value = String::from("closure called"); // 稍后将被克隆
21
let mut num_sort_operations = 0; // 将被可变借用
22

23
list_rect.sort_by_key(|r| {
24
    // 闭包内部修改了捕获的变量 num_sort_operations，因此它必须是 FnMut
25
    sort_operations.push(value.clone()); // value 被克隆，所有权未移动
26
    num_sort_operations += 1;
27
    r.width
28
});
29

30
println!("Sort operations: {}, Count: {}", sort_operations.len(), num_sort_operations);