闭包语法 |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)、回调、延迟计算等场景。每个闭包都有唯一的匿名类型,不捕获环境的闭包可以自动转换为函数指针。