闭包语法 |params| ​

核心概念 ​

闭包(Closure)是 Rust 中的匿名函数,可以赋值给变量、作为参数传递、从函数中返回。闭包用竖线 | 包裹参数列表,函数体可以是单个表达式或用花括号包裹的代码块。和普通函数不同,闭包可以捕获其定义时所在作用域中的变量,这是闭包最核心的能力。闭包的参数类型和返回类型通常可以由编译器自动推断,不需要显式标注。

rust
fn main() {
    // 最简单的闭包:无参数
    let greet = || println!("你好!");
    greet();

    // 一个参数的闭包
    let double = |x| x * 2;
    println!("double(5) = {}", double(5));

    // 两个参数的闭包
    let add = |a, b| a + b;
    println!("add(3, 4) = {}", add(3, 4));

    // 带花括号的多行闭包
    let describe = |name: &str, age: u32| {
        let status = if age >= 18 { "成年" } else { "未成年" };
        format!("{} 今年 {} 岁,{}", name, age, status)
    };
    println!("{}", describe("张三", 25));
    println!("{}", describe("小明", 15));
}

闭包语法与函数语法的对比 ​

rust
// 普通函数:必须标注类型
fn add_fn(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // 闭包的各种写法(从完整到简洁)

    // 写法1:完整标注类型(最接近函数的写法)
    let add_v1 = |a: i32, b: i32| -> i32 { a + b };

    // 写法2:省略返回类型(编译器推断)
    let add_v2 = |a: i32, b: i32| { a + b };

    // 写法3:省略花括号(单表达式时)
    let add_v3 = |a: i32, b: i32| a + b;

    // 写法4:省略参数类型(完全由编译器推断)
    let add_v4 = |a, b| a + b;

    // 所有写法结果相同
    println!("{}", add_fn(1, 2));
    println!("{}", add_v1(1, 2));
    println!("{}", add_v2(1, 2));
    println!("{}", add_v3(1, 2));
    println!("{}", add_v4(1, 2));
}
特性普通函数 fn闭包 ||
参数类型必须标注可省略(编译器推断)
返回类型必须标注(除 () 外)可省略
捕获环境不能可以
赋值给变量函数指针闭包类型
多态通过泛型每个闭包是唯一类型

捕获环境变量 ​

rust
fn main() {
    let name = String::from("Rust");
    let year = 2026;

    // 闭包可以访问外部变量
    let info = || {
        println!("语言: {},年份: {}", name, year);
    };

    info();

    // name 仍然可用(闭包只借用了它)
    println!("外部仍可访问: {}", name);

    // 捕获并修改外部变量(需要 mut)
    let mut counter = 0;
    let mut increment = || {
        counter += 1;  // 可变借用 counter
        println!("计数: {}", counter);
    };

    increment();
    increment();
    increment();

    // increment 不再使用后,counter 恢复可用
    println!("最终计数: {}", counter);
}

闭包作为参数传递 ​

rust
// 接受闭包作为参数
fn apply<F: Fn(i32) -> i32>(f: F, value: i32) -> i32 {
    f(value)
}

fn apply_twice<F: Fn(i32) -> i32>(f: F, value: i32) -> i32 {
    f(f(value))
}

fn main() {
    let double = |x| x * 2;
    let add_ten = |x| x + 10;
    let square = |x| x * x;

    println!("double(5) = {}", apply(double, 5));
    println!("add_ten(5) = {}", apply(add_ten, 5));
    println!("square(5) = {}", apply(square, 5));

    // 连续应用两次
    println!("double(double(3)) = {}", apply_twice(double, 3));
    println!("add_ten(add_ten(5)) = {}", apply_twice(add_ten, 5));

    // 直接传入匿名闭包
    let result = apply(|x| x * x + 2 * x + 1, 3);
    println!("(3+1)^2 = {}", result);
}

基本示例 ​

用闭包实现一个简单的函数式数据处理:

rust
fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // 用闭包做过滤:保留偶数
    let evens: Vec<&i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .collect();
    println!("偶数: {:?}", evens);

    // 用闭包做映射:每个数乘以 3
    let tripled: Vec<i32> = numbers.iter()
        .map(|&x| x * 3)
        .collect();
    println!("三倍: {:?}", tripled);

    // 用闭包做累加
    let sum = numbers.iter().fold(0, |acc, &x| acc + x);
    println!("总和: {}", sum);

    // 组合多个闭包操作
    let result: Vec<String> = numbers.iter()
        .filter(|&&x| x > 3)       // 过滤:大于3
        .map(|&x| x * x)           // 映射:平方
        .filter(|&x| x < 50)       // 再过滤:小于50
        .map(|x| format!("#{}", x)) // 格式化
        .collect();
    println!("组合结果: {:?}", result);

    // 闭包捕获外部变量参与运算
    let threshold = 5;
    let above: Vec<&i32> = numbers.iter()
        .filter(|&&x| x > threshold)
        .collect();
    println!("大于{}: {:?}", threshold, above);
}

常见问题 ​

问题一:闭包的参数类型为什么可以省略?

编译器通过闭包的调用方式来推断参数类型。当你调用 add(3, 4) 时,编译器知道参数是 i32。但一旦类型确定,同一个闭包不能用于不同类型。

问题二:闭包和函数指针有什么区别?

不捕获任何环境变量的闭包可以自动转换为函数指针(fn 类型),但捕获了环境的闭包不能。每个闭包都有自己唯一的匿名类型。

问题三:闭包的花括号什么时候可以省略?

当闭包体是单个表达式时可以省略花括号。如果有多条语句或需要用分号分隔的语句,必须用花括号包裹。

问题四:闭包可以递归调用自己吗?

直接递归不行,因为闭包赋值给变量时还未完成定义。如果需要递归,应该使用普通函数或借助其他手段。

适用场景 ​

  • 迭代器方法:map、filter、fold 等
  • 回调函数:事件处理、异步完成通知
  • 延迟计算:将计算逻辑封装后传递
  • 简短的一次性逻辑:不值得定义完整函数的场景

注意事项 ​

  • 闭包参数类型一旦被推断就固定,不能多态使用
  • 每个闭包都有唯一的匿名类型,即使签名相同
  • 闭包体只有单个表达式时才能省略花括号
  • 不捕获环境的闭包可以转为函数指针
  • 闭包默认按最小权限捕获环境变量

总结 ​

闭包是 Rust 中的匿名函数,用 |params| body 语法定义。参数类型和返回类型通常可以由编译器推断。闭包最大的特点是能捕获定义时所在作用域的变量,这让它比普通函数更灵活。闭包广泛用于迭代器方法(map、filter、fold)、回调、延迟计算等场景。每个闭包都有唯一的匿名类型,不捕获环境的闭包可以自动转换为函数指针。