闭包捕获环境
核心概念
闭包可以捕获其定义时所在作用域中的变量,这是闭包区别于普通函数的核心能力。Rust 编译器会根据闭包体中对变量的使用方式,自动决定用最小权限的方式来捕获:如果只读取,就不可变借用(&T);如果需要修改,就可变借用(&mut T);如果需要移动所有权,就按值捕获(T)。编译器始终选择满足需求的最低权限方式。
rust
fn main() {
// === 不可变借用捕获 ===
let name = String::from("Rust");
let greet = || println!("Hello, {}!", name); // 只读 name,不可变借用
greet();
greet();
println!("name 仍可用: {}", name); // name 没有被移走
// === 可变借用捕获 ===
let mut list = Vec::new();
let mut push_item = || {
list.push(42); // 修改 list,可变借用
};
push_item();
push_item();
// push_item 生命周期结束,可变借用释放
println!("list: {:?}", list); // 可以访问了
// === 按值捕获(所有权转移) ===
let data = vec![1, 2, 3];
let consume = || {
let _owned = data; // 移走 data 的所有权
println!("消耗了 data");
};
consume();
// data 已经被移走,不能再使用
// println!("{:?}", data); // 编译错误
}三种捕获方式
| 捕获方式 | 条件 | 闭包内行为 | 外部变量 | 对应 Trait |
|---|---|---|---|---|
不可变借用 &T | 只读取变量 | 可以读,不能改 | 闭包存活期间仍可不可变借用 | Fn |
可变借用 &mut T | 修改变量 | 可以读写 | 闭包存活期间不能访问 | FnMut |
按值捕获 T | 移走所有权 | 拥有变量 | 不能再使用 | FnOnce |
rust
fn main() {
// 不可变借用:闭包只读取
let x = 10;
let y = 20;
let sum = || x + y; // 不可变借用 x 和 y
println!("sum = {}", sum());
println!("x = {}, y = {}", x, y); // 仍可用
// 可变借用:闭包修改外部变量
let mut total = 0;
let mut add = |n: i32| {
total += n; // 可变借用 total
};
add(10);
add(20);
add(30);
// add 不再使用后,total 恢复可用
println!("total = {}", total); // 60
// 按值捕获:变量被移入闭包
let message = String::from("hello");
let print_and_consume = || {
drop(message); // 需要所有权才能 drop
};
print_and_consume();
// message 已被消耗
}混合捕获
一个闭包可以同时以不同方式捕获多个变量。
rust
fn main() {
let name = String::from("张三"); // 将被不可变借用
let mut scores = vec![80, 90]; // 将被可变借用
let title = String::from("冠军"); // 将被按值捕获(move)
let mut process = || {
println!("姓名: {}", name); // 不可变借用 name
scores.push(100); // 可变借用 scores
let _t = title; // 移走 title 的所有权(闭包内使用后丢弃)
};
process();
// name 仍可用(只被借用)
println!("name: {}", name);
// scores 在闭包结束后可用
println!("scores: {:?}", scores);
// title 已被移走
// println!("{}", title); // 编译错误
}捕获的生命周期
rust
fn main() {
let mut data = vec![1, 2, 3];
// 闭包存活期间,被捕获的变量受借用规则约束
{
let reader = || println!("{:?}", data); // 不可变借用 data
reader();
reader();
// 此时 data 被不可变借用,不能修改
// data.push(4); // 编译错误:不能可变借用
println!("只读: {:?}", data); // 但可以再次不可变借用
}
// reader 离开作用域,借用释放
// 现在可以修改了
data.push(4);
println!("修改后: {:?}", data);
{
let mut writer = || data.push(5); // 可变借用 data
writer();
// data 被可变借用,任何访问都不行
// println!("{:?}", data); // 编译错误
}
// writer 离开作用域,借用释放
println!("最终: {:?}", data);
}Copy 类型的捕获
rust
fn main() {
// Copy 类型(i32, f64, bool 等)即使"按值捕获"也不会移走原变量
let x = 42;
let show = || println!("x = {}", x);
show();
println!("x 仍可用: {}", x); // Copy 类型不受影响
// 但非 Copy 类型(String, Vec 等)按值捕获后原变量不可用
let s = String::from("hello");
let consume = move || println!("s = {}", s); // move 强制按值捕获
consume();
// println!("{}", s); // 编译错误:s 已移入闭包
// Copy 类型 + move:复制一份进闭包,原始变量不受影响
let n = 100;
let show_n = move || println!("n = {}", n);
show_n();
println!("n 仍可用: {}", n); // Copy 了一份
}基本示例
用闭包的环境捕获实现一个简单的计数器和事件记录器:
rust
fn main() {
// 计数器:利用可变借用捕获
let mut count = 0;
let mut next_id = || {
count += 1;
count
};
println!("ID: {}", next_id()); // 1
println!("ID: {}", next_id()); // 2
println!("ID: {}", next_id()); // 3
// 事件记录器:捕获可变 Vec
let mut events: Vec<String> = Vec::new();
let mut log_event = |event: &str| {
let entry = format!("[{}] {}", events.len() + 1, event);
events.push(entry);
};
log_event("系统启动");
log_event("用户登录");
log_event("查询数据");
// 闭包不再使用后,可以访问 events
println!("事件日志:");
for event in &events {
println!(" {}", event);
}
// 累加器:捕获并维护状态
let mut total = 0.0_f64;
let mut record_count = 0_u32;
let mut add_score = |score: f64| {
total += score;
record_count += 1;
total / record_count as f64 // 返回平均值
};
println!("\n成绩录入:");
println!(" 录入 85.0,平均: {:.1}", add_score(85.0));
println!(" 录入 92.0,平均: {:.1}", add_score(92.0));
println!(" 录入 78.0,平均: {:.1}", add_score(78.0));
println!(" 录入 95.0,平均: {:.1}", add_score(95.0));
println!("最终: 共{}条记录,总分{:.1},平均{:.1}",
record_count, total, total / record_count as f64);
}常见问题
问题一:编译器怎么决定用哪种方式捕获?
编译器分析闭包体中对每个变量的使用:只读取就不可变借用,需要修改就可变借用,需要移动就按值捕获。始终选择最低权限。
问题二:为什么可变借用闭包存活期间不能访问被捕获的变量?
和 Rust 的借用规则一致:同一时刻不能同时存在可变借用和其他借用。闭包持有可变借用期间,外部不能再访问该变量。
问题三:闭包捕获的是变量本身还是变量的值?
闭包捕获的是变量的引用或所有权,不是某一时刻的快照。如果不可变借用,读取到的是当前值;如果可变借用,修改的是原始变量。
问题四:怎么强制闭包按值捕获?
使用 move 关键字。move || { ... } 会把所有被引用的变量按值移入闭包。下一节会详细介绍。
适用场景
- 维护状态:计数器、累加器、记录器
- 回调函数:在回调中访问外部上下文
- 迭代器链:
filter、map中使用外部变量作为条件 - 延迟执行:捕获参数后稍后执行
注意事项
- 编译器自动选择最低权限的捕获方式
- 可变借用闭包存活期间,被捕获变量不能被外部访问
- 非 Copy 类型被按值捕获后,原变量不可用
- Copy 类型被按值捕获时是复制,原变量不受影响
- 同一个闭包可以以不同方式捕获不同变量
- 闭包的借用在闭包被丢弃或不再使用时释放
总结
闭包通过捕获环境变量获得了比普通函数更大的灵活性。Rust 编译器根据闭包体中对变量的使用自动选择最低权限的捕获方式:不可变借用(只读)、可变借用(修改)、按值捕获(移走所有权)。捕获期间遵守 Rust 的借用规则——可变借用独占,不可变借用可共享。Copy 类型的按值捕获是复制,不影响原变量。一个闭包可以同时以不同方式捕获多个变量。闭包的借用在闭包生命周期结束时释放。