当前位置：首页 > news >正文

Rust 练习册 3：深入理解闭包（Closure）

news 2025/11/6 13:09:51

闭包是 Rust 中一个强大而灵活的特性，它允许我们定义匿名函数并在需要时捕获环境中的变量。今天我们就来深入学习闭包的使用方法和工作原理。

什么是闭包？

闭包是一种可以捕获其环境的匿名函数。与普通函数不同，闭包可以访问定义时作用域中的变量，这使得它们非常灵活和强大。

基本语法

Rust 中的闭包使用竖线（|）来定义参数，语法如下：

|参数| 表达式

或者更复杂的语法：

|参数| {语句表达式
}

项目中的闭包示例

让我们来看一个来自项目中的实际示例：

fn c_mut2() -> impl for<'a> FnMut(&'a str) -> String {let s = "hello".to_string();move |i| {let mut c = s.clone();c += i;c}
}#[cfg(test)]
mod tests {use crate::c_mut2;#[test]fn it_works() {let i = "world";let mut arr_closure = c_mut2();assert_eq!(arr_closure(i), "helloworld");}
}

在这个例子中，我们定义了一个函数 c_mut2，它返回一个闭包。这个闭包具有以下特点：

它实现了 FnMut trait，意味着它可以修改捕获的变量
使用 move 关键字将变量 s 的所有权移动到闭包中
它接受一个字符串切片参数，并返回一个 String

闭包的三种形式

Rust 中有三种类型的闭包，每种都有不同的 trait：

Fn - 不可变借用捕获的变量

fn fn_example() {let s = "hello";let closure = |x| format!("{} {}", s, x);println!("{}", closure("world")); // 输出: hello world
}

FnMut - 可变借用捕获的变量

fn fn_mut_example() {let mut count = 0;let mut closure = || {count += 1;count};println!("{}", closure()); // 输出: 1println!("{}", closure()); // 输出: 2
}

FnOnce - 获取捕获变量的所有权

fn fn_once_example() {let s = "hello".to_string();let closure = move || {println!("{}", s); // s 的所有权被移动到闭包中};closure();// s 在这里不再可用
}

高阶生命周期约束

在我们的示例中，我们看到了一个特殊的语法：

fn c_mut2() -> impl for<'a> FnMut(&'a str) -> String

这里的 for<'a> 是高阶生命周期约束（Higher-Ranked Trait Bounds），它表示这个闭包可以接受任何生命周期的字符串切片参数。

实际应用场景

迭代器操作

fn iterator_example() {let numbers = vec![1, 2, 3, 4, 5];// 使用闭包进行映射let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();println!("{:?}", doubled); // [2, 4, 6, 8, 10]// 使用闭包进行过滤let evens: Vec<i32> = numbers.iter().filter(|&x| x % 2 == 0).collect();println!("{:?}", evens); // [2, 4]
}

线程处理

use std::thread;fn threading_example() {let s = "Hello".to_string();// 使用 move 闭包在线程间传递数据let handle = thread::spawn(move || {println!("{}", s);});handle.join().unwrap();
}

函数式编程

fn functional_programming_example() {let add = |x, y| x + y;let multiply = |x, y| x * y;fn apply_operation<F>(a: i32, b: i32, operation: F) -> i32 where F: Fn(i32, i32) -> i32 {operation(a, b)}let result1 = apply_operation(5, 3, add);let result2 = apply_operation(5, 3, multiply);println!("5 + 3 = {}", result1); // 8println!("5 * 3 = {}", result2); // 15
}

闭包与环境捕获

闭包可以以三种方式捕获环境中的变量：

不可变引用捕获

fn immutable_capture() {let x = 5;let closure = || {println!("x is: {}", x); // 不可变借用 x};closure();println!("x is still: {}", x); // x 仍然可用
}

可变引用捕获

fn mutable_capture() {let mut x = 5;let mut closure = || {x += 1; // 可变借用 xprintln!("x is now: {}", x);};closure();println!("x is finally: {}", x); // x 的值已改变
}

所有权移动捕获

fn move_capture() {let s = "Hello".to_string();let closure = move || {println!("{}", s); // s 的所有权被移动到闭包中};closure();// s 在这里不再可用，因为所有权已被移动
}

闭包类型推断

Rust 编译器可以自动推断闭包的参数和返回值类型：

fn type_inference_example() {// 编译器推断参数类型和返回类型let square = |x| x * x;println!("{}", square(5)); // 25// 显式指定类型let square_explicit: fn(i32) -> i32 = |x| x * x;println!("{}", square_explicit(5)); // 25
}

闭包与性能

闭包在编译时会被优化，通常与普通函数具有相同的性能：

fn performance_example() {// 闭包版本let numbers = vec![1, 2, 3, 4, 5];let squares: Vec<i32> = numbers.iter().map(|x| x * x).collect();// 函数版本fn square(x: &i32) -> i32 { x * x }let numbers = vec![1, 2, 3, 4, 5];let squares2: Vec<i32> = numbers.iter().map(square).collect();// 这两个版本在编译后通常具有相同的性能
}

最佳实践

1. 选择合适的闭包类型

// 当只需要读取环境变量时，使用 Fn
fn read_only_closure() {let prefix = "Hello";let greeting = |name| format!("{} {}", prefix, name);println!("{}", greeting("World"));
}// 当需要修改环境变量时，使用 FnMut
fn mutable_closure() {let mut counter = 0;let mut increment = || {counter += 1;counter};println!("{}", increment()); // 1println!("{}", increment()); // 2
}// 当需要获取所有权时，使用 FnOnce
fn ownership_closure() {let message = "Hello".to_string();let consume = move || {println!("{}", message); // 消费 message};consume();// message 不再可用
}

2. 合理使用 move 关键字

fn move_keyword_example() {let s = "Hello".to_string();// 不使用 move，闭包借用 s// let closure = || println!("{}", s); // 这会失败，因为闭包需要比 s 更长的生命周期// 使用 move，闭包获取 s 的所有权let closure = move || println!("{}", s);closure();
}