闭包捕获环境 ​

核心概念 ​

闭包可以捕获其定义时所在作用域中的变量,这是闭包区别于普通函数的核心能力。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 类型的按值捕获是复制,不影响原变量。一个闭包可以同时以不同方式捕获多个变量。闭包的借用在闭包生命周期结束时释放。