闭包作为参数 ​

核心概念 ​

将闭包作为函数参数是 Rust 中最常见的闭包用法。函数参数通过 Fn、FnMut 或 FnOnce trait bound 来接受闭包,有三种写法:impl Fn(静态分派)、泛型参数 <F: Fn>(静态分派)、&dyn Fn(动态分派)。静态分派在编译时为每种闭包生成专门的代码,性能最好;动态分派通过 trait 对象在运行时查找方法,更灵活但有少量开销。

rust
// 写法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(...)动态稍慢可以集合、运行时选择
rust
// 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 的闭包 ​

rust
// 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);
}

多个闭包参数 ​

rust
// 接受多个闭包参数
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。

rust
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);
}

基本示例 ​

用闭包参数构建一个可配置的数据处理管道:

rust
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,给调用者最大自由度。