Rust 闭包（快速上手）

什么是 Rust 闭包？从函数到匿名行为的跃迁

在 Rust 编程语言的世界里，函数是构建逻辑的基本单元。但当你开始写更复杂的程序时，会发现有些任务并不适合用传统函数来表达。比如，你可能想把一段代码“打包”起来，像一个可传递的工具一样，随时在不同的地方调用。这时候，Rust 闭包（Closure）就登场了。

你可以把闭包想象成一个微型函数，但它不需要名字，也不需要提前定义。它能“捕获”外部作用域中的变量，就像一个密封的信封，把当前环境里的数据一并装进去。这在处理回调、过滤、映射等场景中非常有用。

比如，你想对一组数字进行筛选，只保留大于 5 的值。用传统函数写法需要先定义一个函数，再传给 filter 方法。而用闭包，你可以直接在调用点写逻辑，代码更紧凑，可读性也更强。

Rust 闭包的语法简洁，但背后的机制却非常强大。它不仅支持函数式编程风格，还能与 Rust 的所有权系统无缝协作。接下来，我们就一步步揭开 Rust 闭包的神秘面纱。

闭包的基本语法与定义方式

Rust 闭包的定义方式非常灵活，最常见的是用 |参数| 表达式 的形式。它的语法结构类似于匿名函数，但更轻量。

// 定义一个闭包，接受一个整数参数，返回其平方
let square = |x: i32| x * x;

// 调用闭包
println!("{}", square(4)); // 输出：16

这个例子中，|x: i32| x * x 就是一个闭包。

• | 是闭包的分隔符，用来包裹参数列表
• x: i32 是参数，类型标注可选，但推荐显式声明以提升可读性
• x * x 是闭包体，即执行逻辑

闭包本身是匿名的，但它可以被赋值给变量，就像普通值一样。这意味着你可以把闭包当作参数传递，也可以从函数中返回。

💡 小贴士：闭包的类型是独一无二的，编译器会根据上下文自动推导。你不能直接声明一个变量为“闭包类型”，但可以使用 impl Fn 这样的 trait 来接受闭包参数。

闭包如何“捕获”外部变量

闭包最惊艳的能力之一，就是“捕获”外部作用域中的变量。这意味着闭包可以访问并使用定义它的函数内部的变量，即使这些变量已经“超出作用域”了。

fn main() {
    let multiplier = 3; // 外部变量

    // 闭包捕获了 multiplier
    let multiply_by_3 = |x: i32| x * multiplier;

    println!("{}", multiply_by_3(5)); // 输出：15
    println!("{}", multiply_by_3(10)); // 输出：30
}

在这个例子中，multiplier 是 main 函数中的局部变量。但闭包 multiply_by_3 却能访问它。这种行为被称为变量捕获。

Rust 有三种捕获方式：

• 移动（Move）：闭包获得变量的所有权（适用于非 Copy 类型）
• 借用（Borrow）：闭包借用变量的引用（不可变或可变）
• 自动推导：Rust 根据使用方式自动选择最合适的方式

fn main() {
    let message = String::from("Hello");

    // 闭包捕获 message，采用 move 方式
    let print_message = move || {
        println!("{}", message); // message 被移动到闭包中
    };

    print_message(); // 输出：Hello
    // println!("{}", message); // 错误！message 已被 move，不可再使用
}

注意：一旦闭包使用了 move，外部变量就不再可用。这体现了 Rust 所有权系统的严谨性。

闭包与函数指针的对比：性能与灵活性的权衡

在 Rust 中，闭包和函数指针都可用于传递行为，但它们在性能和灵活性上有明显差异。

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // 函数指针：指向 add 函数
    let func_ptr: fn(i32, i32) -> i32 = add;

    // 闭包：捕获外部变量
    let add_with_offset = |x: i32| x + 5;

    println!("{}", func_ptr(3, 4));     // 输出：7
    println!("{}", add_with_offset(3)); // 输出：8
}

虽然闭包更灵活，但如果你只是传递一个简单的、固定的函数逻辑，函数指针更高效。闭包适合需要“携带上下文”的场景。

常见的闭包 trait：Fn、FnMut、FnOnce

Rust 为闭包定义了三个核心 trait，用于控制闭包的使用方式。它们决定了闭包能被调用多少次，以及是否能修改外部变量。

Fn：可多次调用，不可变借用外部变量

fn process_with_fn<F>(f: F) 
where 
    F: Fn(i32) -> i32 
{
    println!("{}", f(10));
    println!("{}", f(20)); // 可以多次调用
}

fn main() {
    let add_five = |x: i32| x + 5;
    process_with_fn(add_five); // 输出：15 25
}

FnMut：可多次调用，可变借用外部变量

fn process_with_fnmut<F>(mut f: F) 
where 
    F: FnMut(i32) -> i32 
{
    println!("{}", f(10));
    println!("{}", f(20)); // 可以多次调用
}

fn main() {
    let mut counter = 0;
    let mut increment = |x: i32| {
        counter += 1;
        x + counter
    };

    process_with_fnmut(increment); // 输出：11 13
}

FnOnce：只能调用一次，可能移动变量

fn process_with_fnonce<F>(f: F) 
where 
    F: FnOnce() 
{
    f(); // 只能调用一次
}

fn main() {
    let message = String::from("Hello");
    let closure = move || {
        println!("{}", message); // message 被 move
    };

    process_with_fnonce(closure); // 输出：Hello
    // closure(); // 错误！已调用过，不能再使用
}

✅ 使用建议：

• 如果你不需要修改外部变量，用 Fn
• 如果需要修改，用 FnMut
• 如果闭包会“消耗”变量（如 move），用 FnOnce

实战案例：用 Rust 闭包实现数据处理管道

闭包在实际项目中非常常见，尤其是在数据处理、事件响应、异步编程中。我们来看一个真实场景：从一组用户数据中筛选出年龄大于 18 岁且名字以 "A" 开头的人，并打印他们的名字。

fn main() {
    let users = vec![
        ("Alice", 25),
        ("Bob", 17),
        ("Anna", 20),
        ("Charlie", 30),
        ("Alex", 16),
    ];

    // 使用闭包进行链式处理
    let result: Vec<&str> = users
        .iter()
        .filter(|&(name, age)| age > 18 && name.starts_with('A')) // 筛选
        .map(|&(name, _)| name) // 提取名字
        .collect();

    println!("符合条件的用户：");
    for name in result {
        println!("{}", name);
    }
}

输出：

符合条件的用户：
Alice
Anna

这个例子展示了闭包在函数式编程中的强大能力：

• filter 接收一个闭包，决定是否保留元素
• map 接收一个闭包，转换元素内容
• collect 将结果收集为新集合

闭包让代码更清晰，逻辑更聚焦。你不需要写额外的函数，所有逻辑都在调用点完成。

总结：掌握 Rust 闭包，迈向函数式思维

Rust 闭包是一种强大而优雅的编程工具，它让你能够以更自然的方式表达“行为”而非“函数”。它不仅能捕获上下文，还能与 Rust 的所有权系统协同工作，保证内存安全。

通过本文的学习，你应该已经掌握了：

• 闭包的基本语法与定义方式
• 如何捕获外部变量（包括 move 的使用）
• 闭包与函数指针的区别与选择策略
• Fn、FnMut、FnOnce 三个 trait 的使用场景
• 闭包在实际数据处理中的典型应用

当你在项目中遇到需要“传递一段代码”的场景时，不要急于定义函数。尝试使用闭包，它往往能让你的代码更简洁、更易读。

Rust 闭包不仅是语法糖，更是一种编程范式的体现。掌握它，意味着你正在从“命令式思维”向“函数式思维”迈进。这种转变，会让你写出更安全、更可维护的代码。

现在，是时候在你的下一个项目中，试试用闭包来简化逻辑了。