Rust 中的 `Fn`、`FnMut` 和 `FnOnce` Trait

在 Rust 编程语言中，闭包（closures）是一种功能强大且灵活的特性，允许你定义匿名函数并捕获其环境中的变量。Rust 的闭包系统通过三个核心 trait —— Fn、FnMut 和 FnOnce —— 来定义闭包的行为。这三个 trait 决定了闭包如何与捕获的变量交互、可以被调用多少次以及是否能够修改环境。理解它们对于掌握 Rust 的闭包机制以及编写高效、安全的代码至关重要。

本文将详细介绍 Fn、FnMut 和 FnOnce 这三个 trait，包括它们的定义、用途、使用方法、适用场景，并提供代码示例和最佳实践，帮助你全面学习相关知识。

---

1. 什么是 Fn、FnMut 和 FnOnce？

Fn、FnMut 和 FnOnce 是 Rust 标准库中定义的三个 trait，用于描述闭包（或任何可调用对象）的行为。它们的主要区别在于闭包如何访问捕获的变量以及调用时的所有权规则：

• FnOnce：表示闭包可以被调用一次，调用后闭包本身会被消耗（consume），无法再次使用。
• FnMut：表示闭包可以被多次调用，并且在调用时可以修改捕获的变量。
• Fn：表示闭包可以被多次调用，并且在调用时只读取捕获的变量，不进行修改。

这三个 trait 之间存在继承关系：

• Fn 继承自 FnMut，FnMut 继承自 FnOnce。
• 因此，如果一个闭包实现了 Fn，它也自动实现了 FnMut 和 FnOnce；如果实现了 FnMut，则也实现了 FnOnce。

---

2. 每个 trait 的定义

2.1 FnOnce

FnOnce trait 定义了一个方法 call_once，其签名如下：

pub trait FnOnce<Args> {
    type Output;
    fn call_once(self, args: Args) -> Self::Output;
}

• 特点：call_once 接受 self（而非 &self 或 &mut self），意味着闭包在调用时会转移自身的所有权，因此只能调用一次。
• 用途：适用于闭包需要移动（move）捕获变量或执行一次性操作的场景。

2.2 FnMut

FnMut trait 定义了一个方法 call_mut，其签名如下：

pub trait FnMut<Args>: FnOnce<Args> {
    fn call_mut(&mut self, args: Args) -> Self::Output;
}

• 特点：call_mut 接受 &mut self，允许闭包在调用时修改自身状态或捕获的变量，可以被多次调用。
• 用途：适用于闭包需要多次调用并修改环境的场景。

2.3 Fn

Fn trait 定义了一个方法 call，其签名如下：

pub trait Fn<Args>: FnMut<Args> {
    fn call(&self, args: Args) -> Self::Output;
}

• 特点：call 接受 &self，表示闭包只不可变地借用自身和捕获的变量，可以被多次调用且不修改环境。
• 用途：适用于闭包需要多次调用且只读取数据的场景。

---

3. 闭包如何实现这些 trait

Rust 编译器会根据闭包如何使用捕获的变量，自动推断它实现了哪些 trait。闭包捕获变量的方式有三种：

1. 按值捕获（move）：闭包取得变量的所有权。
2. 可变借用（&mut）：闭包取得变量的可变引用。
3. 不可变借用（&）：闭包取得变量的不可变引用。

实现哪个 trait 取决于捕获变量的使用方式：

• 只实现 FnOnce：闭包移动了捕获的变量。
• 实现 FnMut 和 FnOnce：闭包修改了捕获的变量。
• 实现 Fn、FnMut 和 FnOnce：闭包只读取捕获的变量。

3.1 示例代码

3.1.1 实现 FnOnce 的闭包

fn main() {
    let s = String::from("hello");
    let closure = move || {
        drop(s); // 移动 s 并丢弃
    };
    closure(); // 调用一次
    // closure(); // 错误：闭包已消耗
}

• 解析：闭包使用 move 捕获了 s 的所有权，并在调用时丢弃它。由于 s 被移动，闭包只能调用一次，因此只实现 FnOnce。

3.1.2 实现 FnMut 的闭包

fn main() {
    let mut s = String::from("hello");
    let mut closure = || {
        s.push_str(" world"); // 修改 s
    };
    closure(); // 调用第一次
    closure(); // 调用第二次
    println!("{}", s); // 输出 "hello world world"
}

• 解析：闭包捕获了 s 的可变引用，并在每次调用时修改它。由于需要修改环境，闭包实现 FnMut 和 FnOnce。

3.1.3 实现 Fn 的闭包

fn main() {
    let s = String::from("hello");
    let closure = || {
        println!("{}", s); // 只读取 s
    };
    closure(); // 调用第一次
    closure(); // 调用第二次
}

• 解析：闭包捕获了 s 的不可变引用，只读取而不修改，因此实现 Fn、FnMut 和 FnOnce。

---

4. 在函数参数中使用这些 trait

闭包可以作为参数传递给函数，而函数需要通过 trait bound 指定闭包的行为。

4.1 使用 FnOnce

fn call_once<F>(f: F)
where
    F: FnOnce(),
{
    f();
}

fn main() {
    let s = String::from("hello");
    call_once(move || {
        drop(s);
    });
}

• 解析：call_once 接受一个 FnOnce 闭包并调用一次，适用于移动捕获变量的场景。

4.2 使用 FnMut

fn call_mut<F>(mut f: F)
where
    F: FnMut(),
{
    f();
    f();
}

fn main() {
    let mut s = String::from("hello");
    call_mut(|| {
        s.push_str(" world");
    });
    println!("{}", s); // 输出 "hello world world"
}

• 解析：call_mut 接受一个 FnMut 闭包并调用两次，闭包可以修改捕获的变量。注意 f 必须标记为 mut。

4.3 使用 Fn

fn call_fn<F>(f: F)
where
    F: Fn(),
{
    f();
    f();
}

fn main() {
    let s = String::from("hello");
    call_fn(|| {
        println!("{}", s);
    });
}

• 解析：call_fn 接受一个 Fn 闭包并调用两次，闭包只读取捕获的变量。

---

5. 什么时候使用哪个 trait？

选择合适的 trait 取决于闭包的行为需求：

• FnOnce：
  • 场景：闭包只调用一次，或需要移动捕获的变量。
  • 例子：将所有权转移到其他地方的一次性操作。
• FnMut：
  • 场景：闭包需多次调用并修改捕获的变量。
  • 例子：计数器或状态更新。
• Fn：
  • 场景：闭包需多次调用且只读取捕获的变量。
  • 例子：日志记录或数据查询。

在设计函数时，选择最宽松的 trait 可以增加灵活性。例如，FnOnce 接受所有闭包，但限制调用次数；Fn 要求不修改环境，但允许多次调用。

---

6. 最佳实践

1. 优先使用 Fn：
   • 如果闭包无需修改变量，使用 Fn，因为它限制最少，兼容性最高。
2. 需要修改时使用 FnMut：
   • 当闭包需要更新状态时，选择 FnMut。
3. 仅调用一次时使用 FnOnce：
   • 当闭包移动变量或执行一次性任务时，使用 FnOnce。
4. API 设计时选择合适的限制：
   • 根据函数需求选择 trait：单次调用用 FnOnce，多次只读用 Fn，多次修改用 FnMut。
5. 注意生命周期：
   • 确保捕获变量的生命周期覆盖闭包的调用范围，避免借用错误。

---

Pomelo_刘金，转载请注明链接，感谢！