目录

  1. 什么是 Rust 闭包
  2. 为什么要使用闭包
  3. 闭包的定义与语法
  4. 闭包的捕获方式
  5. 闭包与函数的区别
  6. 代码示例
  7. 参考资料与出站链接

什么是 Rust 闭包

Rust 闭包 (Closures) 是一种匿名函数，可以捕获其定义时的环境变量。它们使用 |参数| 表达式 语法定义，支持灵活的函数式编程风格，常用于迭代器和高阶函数。

为什么要使用闭包

  • 捕获环境：访问外部作用域的变量。
  • 简洁性：无需显式定义命名函数。
  • 函数式编程：与迭代器、映射等操作结合。
  • 动态性：支持运行时生成的逻辑。

闭包的定义与语法

  • 基本语法：|参数| 表达式。
  • 类型推导：参数和返回值类型通常由编译器推断。
  • 显式类型：可使用 |参数: 类型| -> 返回类型 { 代码块 }。
let add_one = |x| x + 1;

闭包的捕获方式

闭包根据捕获外部变量的方式实现以下 trait：

  1. Fn：
  • 不可变借用环境（&self）。
  • 可多次调用。
  1. FnMut：
  • 可变借用环境（&mut self）。
  • 可修改捕获的变量。
  1. FnOnce：
  • 消费环境（self）。
  • 只能调用一次，转移所有权。
  • 捕获规则：
  • 默认尽量借用（&）。
  • 使用 move 关键字强制转移所有权。

闭包与函数的区别

  • 环境捕获：闭包可捕获外部变量，函数不行。
  • 匿名性：闭包无需命名。
  • 类型：闭包是唯一类型，函数是具名类型。
  • 性能：闭包可能有轻微开销（捕获环境）。

代码示例

基本闭包

fn main() {
    let base = 10;
    let add_base = |x| x + base;  // 捕获 base
    println!("5 + base = {}", add_base(5));
}

运行结果：

5 + base = 15

不同捕获方式

fn main() {
    let mut count = 0;

    // Fn: 不可变借用
    let print_count = || println!("Count: {}", count);
    print_count();

    // FnMut: 可变借用
    let mut increment = || count += 1;
    increment();
    println!("After increment: {}", count);

    // FnOnce: 消费所有权
    let value = String::from("Rust");
    let consume = move || println!("Consumed: {}", value);
    consume();
    // println!("{}", value);  // 错误：value 已转移
}

运行结果：

Count: 0
After increment: 1
Consumed: Rust

闭包与迭代器

fn main() {
    let numbers = vec![1, 2, 3, 4];
    let doubled: Vec<i32> = numbers.into_iter()
        .map(|x| x * 2)
        .collect();
    println!("Doubled: {:?}", doubled);
}

运行结果：

Doubled: [2, 4, 6, 8]

参考资料与出站链接

  1. 官方文档：
  1. 学习资源：
  1. 社区支持：