闭包作为参数
核心概念
将闭包作为函数参数是 Rust 中最常见的闭包用法。函数参数通过 Fn、FnMut 或 FnOnce trait bound 来接受闭包,有三种写法:impl Fn(静态分派)、泛型参数 <F: Fn>(静态分派)、&dyn Fn(动态分派)。静态分派在编译时为每种闭包生成专门的代码,性能最好;动态分派通过 trait 对象在运行时查找方法,更灵活但有少量开销。
// 写法1:impl Trait(简洁,常用)
fn apply_impl(f: impl Fn(i32) -> i32, x: i32) -> i32 {
f(x)
}
// 写法2:泛型参数(可以在多处引用同一个类型 F)
fn apply_generic<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
f(x)
}
// 写法3:trait 对象(动态分派,可存入集合)
fn apply_dyn(f: &dyn Fn(i32) -> i32, x: i32) -> i32 {
f(x)
}
fn main() {
let double = |x| x * 2;
println!("impl: {}", apply_impl(double, 5));
println!("generic: {}", apply_generic(double, 5));
println!("dyn: {}", apply_dyn(&double, 5));
}三种写法的对比
| 写法 | 分派方式 | 性能 | 集合存储 | 适用场景 |
|---|---|---|---|---|
impl Fn(...) | 静态 | 最好 | 不能 | 简单参数 |
<F: Fn(...)> | 静态 | 最好 | 不能 | 需要引用类型参数 F |
&dyn Fn(...) | 动态 | 稍慢 | 可以 | 集合、运行时选择 |
// impl Fn 和泛型参数在大多数场景等价
fn process_impl(data: &[i32], f: impl Fn(i32) -> i32) -> Vec<i32> {
data.iter().map(|&x| f(x)).collect()
}
fn process_generic<F>(data: &[i32], f: F) -> Vec<i32>
where
F: Fn(i32) -> i32,
{
data.iter().map(|&x| f(x)).collect()
}
// 泛型参数的优势:可以保证多个参数是同一个闭包类型
fn apply_both<F: Fn(i32) -> i32>(f: F, a: i32, b: i32) -> (i32, i32) {
(f(a), f(b))
}
fn main() {
let data = vec![1, 2, 3, 4, 5];
let r1 = process_impl(&data, |x| x * x);
let r2 = process_generic(&data, |x| x + 10);
println!("平方: {:?}", r1);
println!("加10: {:?}", r2);
let (a, b) = apply_both(|x| x * 3, 10, 20);
println!("({}, {})", a, b);
}接受不同 trait bound 的闭包
// FnOnce:只调用一次(最宽松,接受所有闭包)
fn run_once<F: FnOnce() -> String>(f: F) -> String {
f()
}
// FnMut:可能多次调用,可修改状态
fn run_times<F: FnMut(usize)>(mut f: F, times: usize) {
for i in 0..times {
f(i);
}
}
// Fn:多次调用,不修改状态
fn run_readonly<F: Fn(i32) -> String>(f: F, values: &[i32]) -> Vec<String> {
values.iter().map(|&v| f(v)).collect()
}
fn main() {
// FnOnce
let data = vec![1, 2, 3];
let result = run_once(|| {
let sum: i32 = data.into_iter().sum();
format!("总和: {}", sum)
});
println!("{}", result);
// FnMut
let mut log = Vec::new();
run_times(|i| {
log.push(format!("步骤 {}", i + 1));
}, 4);
println!("日志: {:?}", log);
// Fn
let prefix = "数字";
let formatted = run_readonly(
|v| format!("{}: {}", prefix, v),
&[10, 20, 30],
);
println!("格式化: {:?}", formatted);
}多个闭包参数
// 接受多个闭包参数
fn transform_and_filter<T, U>(
items: Vec<T>,
transformer: impl Fn(T) -> U,
predicate: impl Fn(&U) -> bool,
) -> Vec<U> {
items.into_iter()
.map(transformer)
.filter(predicate)
.collect()
}
// 条件执行不同闭包
fn conditional<F1, F2, R>(condition: bool, on_true: F1, on_false: F2) -> R
where
F1: FnOnce() -> R,
F2: FnOnce() -> R,
{
if condition { on_true() } else { on_false() }
}
// 组合两个函数
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
move |x| g(f(x))
}
fn main() {
// 转换并过滤
let words = vec!["hello", "hi", "hey", "howdy", "greetings"];
let result = transform_and_filter(
words,
|w| (w.to_uppercase(), w.len()),
|(_, len)| *len <= 5,
);
println!("短词: {:?}", result);
// 条件执行
let is_debug = true;
let msg = conditional(
is_debug,
|| String::from("调试模式"),
|| String::from("生产模式"),
);
println!("{}", msg);
// 函数组合
let double_then_add = compose(|x: i32| x * 2, |x| x + 1);
println!("(5*2)+1 = {}", double_then_add(5));
}闭包参数与普通函数
普通函数也可以作为闭包参数传递,因为函数指针实现了所有三个闭包 trait。
fn square(x: i32) -> i32 {
x * x
}
fn negate(x: i32) -> i32 {
-x
}
fn apply_to_all(data: &[i32], f: impl Fn(i32) -> i32) -> Vec<i32> {
data.iter().map(|&x| f(x)).collect()
}
fn main() {
let nums = vec![1, 2, 3, 4, 5];
// 传入普通函数
let squared = apply_to_all(&nums, square);
println!("平方: {:?}", squared);
let negated = apply_to_all(&nums, negate);
println!("取反: {:?}", negated);
// 传入闭包
let factor = 3;
let tripled = apply_to_all(&nums, |x| x * factor);
println!("三倍: {:?}", tripled);
// 传入函数指针
let fp: fn(i32) -> i32 = square;
let result = apply_to_all(&nums, fp);
println!("函数指针: {:?}", result);
}基本示例
用闭包参数构建一个可配置的数据处理管道:
struct Pipeline<T> {
data: Vec<T>,
}
impl<T> Pipeline<T> {
fn new(data: Vec<T>) -> Self {
Pipeline { data }
}
fn filter(self, predicate: impl Fn(&T) -> bool) -> Self {
Pipeline {
data: self.data.into_iter().filter(|x| predicate(x)).collect(),
}
}
fn transform<U>(self, mapper: impl Fn(T) -> U) -> Pipeline<U> {
Pipeline {
data: self.data.into_iter().map(mapper).collect(),
}
}
fn inspect(self, action: impl Fn(&T)) -> Self {
for item in &self.data {
action(item);
}
self
}
fn reduce<R>(self, init: R, folder: impl Fn(R, T) -> R) -> R {
self.data.into_iter().fold(init, folder)
}
fn collect(self) -> Vec<T> {
self.data
}
fn count(self) -> usize {
self.data.len()
}
}
fn main() {
// 数字处理管道
let result = Pipeline::new(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
.filter(|&x| x % 2 == 0) // 保留偶数
.transform(|x| x * x) // 平方
.inspect(|x| print!("{} ", x)) // 打印中间结果
.filter(|&x| x > 10) // 保留大于10的
.collect();
println!();
println!("结果: {:?}", result);
// 字符串处理管道
let words = vec![" Hello ", "WORLD", " rust ", "Programming"];
let processed = Pipeline::new(words)
.transform(|s| s.trim().to_lowercase())
.filter(|s| s.len() > 4)
.transform(|s| format!("'{}'", s))
.collect();
println!("处理后: {:?}", processed);
// 聚合计算
let total = Pipeline::new(vec![10.0, 20.5, 30.0, 15.5, 25.0])
.filter(|&x| x > 15.0)
.reduce(0.0, |acc, x| acc + x);
println!("总和: {:.1}", total);
}常见问题
问题一:应该选择 Fn、FnMut 还是 FnOnce?
根据函数体中对闭包的调用方式选择:调用一次用 FnOnce(最宽松),多次调用且可能修改状态用 FnMut,多次调用且不修改状态用 Fn。
问题二:impl Fn 和 <F: Fn> 有什么区别?
大多数场景等价。泛型参数的优势是可以在函数签名的多个位置引用同一个类型 F(如返回 F),impl Fn 做不到。
问题三:什么时候用 &dyn Fn 而不是 impl Fn?
当需要在集合中存储不同的闭包、或者需要在运行时动态选择闭包时用 &dyn Fn。性能要求高的热路径用 impl Fn。
问题四:可以同时传普通函数和闭包吗?
可以。普通函数自动实现 Fn、FnMut、FnOnce,可以传给任何接受闭包的参数。
适用场景
- 数据处理:
map、filter、fold等操作 - 回调/钩子:事件处理、中间件
- 策略模式:可替换的算法
- 管道/链式调用:可配置的处理流程
注意事项
- 选择最宽松的 trait bound:FnOnce > FnMut > Fn
impl Fn和泛型参数在大多数场景等价FnMut参数需要mut修饰- 普通函数可以作为闭包参数传递
- 动态分派(
dyn Fn)比静态分派有少量开销 - 多个闭包参数各自是独立的泛型类型
总结
闭包作为函数参数有三种写法:impl Fn(简洁)、泛型 <F: Fn>(可引用类型 F)、&dyn Fn(动态分派)。根据调用次数选择 trait bound:只调用一次用 FnOnce,多次调用可修改用 FnMut,多次调用只读用 Fn。普通函数也可以作为闭包参数传递。多个闭包参数各自是独立的泛型类型。静态分派性能好但不能存入集合,动态分派灵活但有少量开销。优先选择最宽松的 trait bound,给调用者最大自由度。