rust学习笔记21-闭包

        在 Rust 中，闭包（Closures） 是一种可以捕获其环境中的变量的匿名函数。它们非常灵活，既可以作为普通函数使用，也可以捕获和操作定义它们的作用域中的变量。闭包是 Rust 中处理短小逻辑代码块的强大工具，特别是在需要将逻辑作为参数传递给其他函数时。

1. 基本语法

闭包的语法简洁，用 |参数| { 代码块 } 表示：

// 无参数的闭包
let greet = || println!("Hello, Rust!");
greet();// 带参数的闭包
let add = |a: i32, b: i32| -> i32 { a + b };
println!("Sum: {}", add(3, 5));// 类型可省略（编译器自动推断）
let multiply = |x, y| x * y; 
println!("Product: {}", multiply(4, 5));

 2. 捕获环境变量
闭包可以捕获其定义时的作用域变量，捕获方式分为三种（对应三个 trait）：
        不可变借用（Fn）：只读取环境变量。
        可变借用（FnMut）：可修改环境变量。
        所有权转移（FnOnce）：消费环境变量（只能调用一次）。

fn main() {// 不可变借用let name = "rust";let print_name = || println!("Name: {}", name); // 捕获 name 的不可变引用print_name(); // 可多次调用// 可变借用let mut count = 0;let mut increment = || { count += 1; // 捕获可变引用println!("Count: {}", count);};increment(); // 可多次调用，但闭包本身需声明为 mut// 所有权移动let x = vec![1, 2, 3];let closure = move || println!("x: {:?}", x); // 获取所有权closure();//println!("{:?}", x); // 错误: x 已被移动到闭包中}

3. 闭包作为函数参数

闭包经常被用作函数参数，特别是对于高阶函数（Higher-order Functions），例如 map, filter, fold 等。

示例：使用闭包过滤偶数

fn main() {let numbers = vec![1, 2, 3, 4, 5, 6];let even_numbers: Vec<i32> = numbers.into_iter().filter(|&x| x % 2 == 0).collect();println!("Even numbers: {:?}", even_numbers); // 输出: Even numbers: [2, 4, 6]
}

4. 闭包与 Trait
Rortex 内部使用了三个 Trait 来表示闭包的行为：
Fn: 表示闭包可以通过引用调用。
FnMut: 表示闭包可以通过可变引用调用。
FnOnce: 表示闭包只能调用一次，通常是因为它需要获取环境变量的所有权。

// 接受 Fn 闭包（不可变借用）
fn run_closure<F: Fn()>(f: F) {f();
}// 接受 FnMut 闭包（可变借用）
fn run_mut_closure<F: FnMut()>(mut f: F) {f();
}// 接受 FnOnce 闭包（所有权转移）
fn run_once_closure<F: FnOnce()>(f: F) {f();
}

5. 性能特点
零成本抽象：闭包通常被编译为普通函数，无运行时开销。
内联优化：编译器可能将闭包内联，提升性能。
内存分配：默认在栈上分配，使用 Box 时才会堆分配。

6.线程中传递闭包

fn main() {use std::thread;let value = 42;let handle = thread::spawn(move || { // 强制转移所有权到线程println!("Value in thread: {}", value);});handle.join().unwrap();
}

总结

Rust 闭包通过以下机制实现强大功能：
        灵活捕获环境：支持不可变/可变借用和所有权转移。
        零成本抽象：编译时生成高效代码。
        类型安全：通过 Fn、FnMut、FnOnce trait 保证行为正确性。
通过合理利用闭包，你可以写出更加直观、高效的代码，尤其是在处理数据转换、异步编程等场景下。