rust中的闭包

什么是闭包？

闭包常以匿名函数的形式出现，但其本质是函数+引用其作用域中变量的环境组合而成的对象。其有三种主要的形式，一种是作为函数的参数传入或者被作为函数的返回值返回出去，并且一个闭包的匿名函数其能被赋予一个变量。其核心的特性是，能捕获其调用者上下文作用域中的变量。

💡提示
Rust 中闭包通常是匿名的，但不是不能具名。你可以将闭包赋值给具名变量，或让具名函数返回闭包。

闭包与函数的核心区别在于：**闭包可以捕获上下文变量**，而普通函数不能。

**闭包（Closure）是一个函数，**它可以访问并“记住”其创建时所在的词法作用域中的变量，**即使这个函数是在其定义作用域之外被调用。**

闭包与普通函数

🧠 关键点对比：闭包 vs 普通函数（Rust）

一个简单的闭包函数

rust
折叠复制
fn main() {
    println!("Hello, world!");

    // 创建一个闭包

    let a = 3;
    let sum = |x| x + a; 
    let result = sum(3);
    // 调用
    println!("sum的结果是：{}", sum(3));
    println!("result的结果是:{}",result);
}

闭包的类型推导

rust语言是一门静态语言，通常如果不去明确的写其类型，其rust编译器会手动的为rust去写类型。 比如，如下代码实际上等同于：

rust
折叠复制
let x = 3;
let sum = |x| x + y;

rust
折叠复制
let x = 3;
let sum = |x:i32|:i32 { x + y};

闭包的3中Fn特征

🔧 1. Fn：只读调用

• 只能借用环境变量（不可变借用 &T）。

• 支持多次调用，不会改变环境变量。

• 最常用于函数式编程风格，比如 .map()、.filter() 等。

rust
折叠复制
let x = 10;
let closure = |y| x + y; // x 被不可变借用
println!("{}", closure(5)); // 多次调用没问题

---

使用场景：

• 传入函数中做只读计算

• 可以多次调用、不会修改外部状态

---

🔧 2. FnMut：可变调用

• 会可变借用捕获的变量（&mut T）。

• 闭包内部可以修改环境变量的状态。

• 支持多次调用，但要求外部变量可变。

rust
折叠复制
let mut x = 0;
let mut closure = |y| { x += y; x }; // x 被可变借用
println!("{}", closure(2)); // ok
println!("{}", closure(3)); // ok

---

使用场景：

• 你想在闭包中更新某些状态（如计数器）

• 传入 .for_each() 改变外部变量

---

🔧 3. FnOnce：只能调用一次

• 闭包会获取变量所有权（T），用完就走。

• 一次性调用之后不能再次调用。

• 最灵活，也是所有闭包的最基础 Trait。

rust
折叠复制
let s = String::from("hello");
let closure = move |name| { // s 被 move 了
    println!("{}, {}", s, name);
};
// println!("{}", s); // ❌ s 被 move 了
closure("world"); // ok
// closure("again"); // ❌ can't call twice

---

使用场景：

• 闭包中需要消费（move）捕获的变量

• 适合异步、线程、一次性执行等场景

---

🧠 它们的关系（子集关系）

text
折叠复制
Fn
        |
      FnMut
        |
     FnOnce

---

• 所有 Fn 闭包 都是 FnMut 和 FnOnce

• 所有 FnMut 闭包 也是 FnOnce

• 你可以把 FnOnce 看成最宽松，Fn 是最严格

---

Rust 中闭包作为函数返回值

Rust 的闭包（closure）是匿名函数类型，且类型复杂（编译器自动推断，具体类型内部实现细节不同）。要返回闭包，需要注意：

• Rust 不能直接写出闭包的具体类型，因为闭包是匿名且编译器生成的。

• 需要用 impl Fn* 或者 Box<dyn Fn*> 这种方式返回闭包。

---

1. 返回 impl Fn（匿名闭包类型）——最常用写法

rust
折叠复制
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn main() {
    let add_5 = make_adder(5);
    println!("{}", add_5(3)); // 8
}

---

说明：

• impl Fn(i32) -> i32 表示函数返回了一个实现了 Fn(i32) -> i32 的闭包类型（不暴露具体类型）。

• move 关键字确保闭包捕获 x 的所有权，可以安全返回。

---

2. 返回 Box<dyn Fn>——动态分发（运行时）

如果想返回多种不同闭包，或者闭包类型无法用 impl Fn 统一时，可以用：

rust
折叠复制
fn make_adder_boxed(x: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |y| x + y)
}

fn main() {
    let add_5 = make_adder_boxed(5);
    println!("{}", add_5(3)); // 8
}

---

说明：

• Box<dyn Fn(i32) -> i32> 是一个 trait 对象，存放在堆上。

• 适合返回多种不同闭包，但会带来一点运行时开销。

---

3. 为什么不能直接写返回闭包的具体类型？

闭包类型是匿名且独一无二的，类似：

rust
折叠复制
let closure = |x| x + 1;

---

它的具体类型是编译器生成的、无法手写。你只能：

• 用 impl Fn... 让编译器帮你隐藏具体类型

• 或用 Box<dyn Fn...> 动态封装

---

4. 返回闭包的常见错误示范：

rust
折叠复制
fn bad() -> Fn(i32) -> i32 {
    |x| x + 1
}
// 错误，Fn 是 trait，不能作为返回类型，必须用 impl 或 Box<dyn Fn>

---

---

5. 小结

---