闭包作为返回值 ​

核心概念 ​

函数可以返回闭包,让调用者获得一个可调用的值。由于每个闭包都有唯一的匿名类型,不能直接写出闭包的具体类型名称,所以返回闭包有两种方式:impl Fn(静态分派,栈上分配)和 Box<dyn Fn>(动态分派,堆上分配)。如果闭包需要捕获函数内的局部变量,必须使用 move 将变量移入闭包,否则闭包中的借用会指向已释放的栈帧。

rust
// 用 impl Fn 返回闭包(静态分派)
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n  // move 将 n 移入闭包
}

// 用 Box<dyn Fn> 返回闭包(动态分派)
fn make_multiplier(factor: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x * factor)
}

fn main() {
    let add_five = make_adder(5);
    let add_ten = make_adder(10);

    println!("add_five(3) = {}", add_five(3));   // 8
    println!("add_ten(3) = {}", add_ten(3));     // 13

    let double = make_multiplier(2);
    let triple = make_multiplier(3);

    println!("double(7) = {}", double(7));   // 14
    println!("triple(7) = {}", triple(7));   // 21
}

impl Fn vs Box<dyn Fn> ​

特性impl FnBox<dyn Fn>
分派方式静态(编译时确定)动态(运行时查表)
内存分配栈堆
性能更好有间接调用开销
条件返回不同闭包不能可以
存入集合不能可以
rust
// impl Fn:只能返回一种闭包
fn always_same(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}

// Box<dyn Fn>:可以根据条件返回不同的闭包
fn choose_operation(op: &str) -> Box<dyn Fn(i32, i32) -> i32> {
    match op {
        "add" => Box::new(|a, b| a + b),
        "sub" => Box::new(|a, b| a - b),
        "mul" => Box::new(|a, b| a * b),
        "div" => Box::new(|a, b| if b != 0 { a / b } else { 0 }),
        _ => Box::new(|a, _| a),  // 默认:返回第一个参数
    }
}

fn main() {
    let f = always_same(100);
    println!("f(5) = {}", f(5));

    let ops = vec!["add", "sub", "mul", "div"];
    for op in ops {
        let func = choose_operation(op);
        println!("{}: 10 op 3 = {}", op, func(10, 3));
    }
}

move 的必要性 ​

rust
// 返回闭包时必须用 move,否则闭包借用了函数的局部变量
fn make_greeter(name: String) -> impl Fn() -> String {
    // move 将 name 移入闭包
    // 没有 move 的话,闭包借用了 name,但 name 在函数返回时就被释放了
    move || format!("你好, {}!", name)
}

// 多个变量都需要 move
fn make_formatter(prefix: String, suffix: String) -> impl Fn(&str) -> String {
    move |content| format!("{}{}{}", prefix, content, suffix)
}

// Copy 类型会被复制进闭包
fn make_range_checker(min: i32, max: i32) -> impl Fn(i32) -> bool {
    move |x| x >= min && x <= max  // min, max 是 Copy 类型
}

fn main() {
    let greet = make_greeter(String::from("张三"));
    println!("{}", greet());
    println!("{}", greet());  // 可以多次调用

    let wrap = make_formatter(String::from("<<"), String::from(">>"));
    println!("{}", wrap("重要内容"));
    println!("{}", wrap("另一条"));

    let in_range = make_range_checker(1, 100);
    println!("50 在范围内: {}", in_range(50));
    println!("150 在范围内: {}", in_range(150));
}

返回 FnMut 和 FnOnce ​

rust
// 返回 FnMut:闭包有可变状态
fn make_counter(start: i32) -> impl FnMut() -> i32 {
    let mut current = start;
    move || {
        current += 1;
        current
    }
}

// 返回 FnOnce:闭包只能调用一次
fn make_finalizer(data: Vec<i32>) -> impl FnOnce() -> i32 {
    move || {
        // into_iter 消耗 data
        data.into_iter().sum()
    }
}

// 返回 Box<dyn FnMut>
fn make_accumulator(init: f64) -> Box<dyn FnMut(f64) -> f64> {
    let mut total = init;
    Box::new(move |value| {
        total += value;
        total
    })
}

fn main() {
    // FnMut 返回值
    let mut counter = make_counter(0);
    println!("计数: {}, {}, {}", counter(), counter(), counter());

    // FnOnce 返回值
    let finalizer = make_finalizer(vec![1, 2, 3, 4, 5]);
    println!("总和: {}", finalizer());
    // finalizer();  // 编译错误:已消耗

    // Box<dyn FnMut> 返回值
    let mut acc = make_accumulator(100.0);
    println!("累加: {:.1}", acc(10.0));   // 110.0
    println!("累加: {:.1}", acc(20.0));   // 130.0
    println!("累加: {:.1}", acc(30.0));   // 160.0
}

闭包工厂模式 ​

rust
// 构建不同的字符串处理器
fn make_processor(mode: &str) -> Box<dyn Fn(&str) -> String> {
    match mode {
        "upper" => Box::new(|s| s.to_uppercase()),
        "lower" => Box::new(|s| s.to_lowercase()),
        "reverse" => Box::new(|s| s.chars().rev().collect()),
        "trim" => Box::new(|s| s.trim().to_string()),
        "quote" => Box::new(|s| format!("\"{}\"", s)),
        _ => Box::new(|s| s.to_string()),
    }
}

// 组合多个处理器
fn chain_processors(
    processors: Vec<Box<dyn Fn(&str) -> String>>,
) -> Box<dyn Fn(&str) -> String> {
    Box::new(move |input| {
        let mut result = input.to_string();
        for proc in &processors {
            result = proc(&result);
        }
        result
    })
}

fn main() {
    // 单个处理器
    let upper = make_processor("upper");
    let reverse = make_processor("reverse");
    println!("{}", upper("hello"));      // HELLO
    println!("{}", reverse("hello"));    // olleh

    // 组合处理器
    let pipeline = chain_processors(vec![
        make_processor("trim"),
        make_processor("upper"),
        make_processor("quote"),
    ]);
    println!("{}", pipeline("  hello world  "));  // "HELLO WORLD"

    // 动态构建处理链
    let modes = vec!["lower", "reverse"];
    let processors: Vec<Box<dyn Fn(&str) -> String>> = modes
        .iter()
        .map(|&m| make_processor(m))
        .collect();
    let dynamic_pipeline = chain_processors(processors);
    println!("{}", dynamic_pipeline("Hello World"));  // dlrow olleh
}

基本示例 ​

用返回闭包构建一个可配置的验证器工厂:

rust
type Validator = Box<dyn Fn(&str) -> Result<(), String>>;

// 验证器工厂函数
fn min_length(min: usize) -> Validator {
    Box::new(move |s| {
        if s.len() >= min {
            Ok(())
        } else {
            Err(format!("长度不能少于{},当前: {}", min, s.len()))
        }
    })
}

fn max_length(max: usize) -> Validator {
    Box::new(move |s| {
        if s.len() <= max {
            Ok(())
        } else {
            Err(format!("长度不能超过{},当前: {}", max, s.len()))
        }
    })
}

fn contains_char(ch: char) -> Validator {
    Box::new(move |s| {
        if s.contains(ch) {
            Ok(())
        } else {
            Err(format!("必须包含字符 '{}'", ch))
        }
    })
}

fn matches_pattern(pattern: &str, description: &str) -> Validator {
    let desc = description.to_string();
    let pat = pattern.to_string();
    Box::new(move |s| {
        if s.contains(&pat) {
            Ok(())
        } else {
            Err(format!("必须满足: {}", desc))
        }
    })
}

fn no_whitespace() -> Validator {
    Box::new(|s| {
        if s.chars().any(|c| c.is_whitespace()) {
            Err(String::from("不能包含空格"))
        } else {
            Ok(())
        }
    })
}

// 组合多个验证器
fn combine_validators(validators: Vec<Validator>) -> Validator {
    Box::new(move |s| {
        let mut errors = Vec::new();
        for v in &validators {
            if let Err(e) = v(s) {
                errors.push(e);
            }
        }
        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors.join("; "))
        }
    })
}

fn main() {
    // 构建密码验证器
    let password_validator = combine_validators(vec![
        min_length(8),
        max_length(32),
        no_whitespace(),
        contains_char('@'),
    ]);

    // 构建用户名验证器
    let username_validator = combine_validators(vec![
        min_length(3),
        max_length(20),
        no_whitespace(),
    ]);

    // 测试密码
    let passwords = vec!["ab", "hello world", "short", "valid@password123"];
    println!("=== 密码验证 ===");
    for pwd in passwords {
        match password_validator(pwd) {
            Ok(()) => println!("  '{}' → 通过", pwd),
            Err(e) => println!("  '{}' → 失败: {}", pwd, e),
        }
    }

    // 测试用户名
    let usernames = vec!["ab", "hello world", "valid_user", "a_very_long_username_exceeding_limit"];
    println!("\n=== 用户名验证 ===");
    for name in usernames {
        match username_validator(name) {
            Ok(()) => println!("  '{}' → 通过", name),
            Err(e) => println!("  '{}' → 失败: {}", name, e),
        }
    }
}

常见问题 ​

问题一:为什么返回闭包必须用 move?

函数返回后,局部变量就被释放了。如果闭包只借用这些变量,返回后引用就变成悬垂引用。move 将变量移入闭包,闭包拥有数据的所有权,不依赖原函数的栈帧。

问题二:什么时候用 impl Fn,什么时候用 Box<dyn Fn>?

如果函数只返回一种闭包(不根据条件返回不同闭包),用 impl Fn,性能更好。如果需要根据条件返回不同的闭包,或者需要存入集合,用 Box<dyn Fn>。

问题三:返回的闭包可以有可变状态吗?

可以,返回 impl FnMut 或 Box<dyn FnMut>。调用时变量需要声明为 mut。

问题四:返回闭包的生命周期有什么限制?

返回的闭包不能借用函数的局部变量(必须 move)。如果闭包需要引用外部数据,那个数据的生命周期必须足够长(通常是 'static)。

适用场景 ​

  • 工厂模式:根据参数创建不同行为的函数
  • 策略模式:运行时选择不同的算法
  • 柯里化:将多参数函数转换为单参数函数链
  • 中间件/管道:链式组合多个处理步骤

注意事项 ​

  • 返回闭包时几乎总是需要 move
  • impl Fn 不能根据条件返回不同闭包
  • Box<dyn Fn> 有堆分配和虚调用的开销
  • 返回 FnMut 需要调用者用 mut 绑定
  • 返回 FnOnce 的闭包只能调用一次
  • 闭包捕获的引用数据必须有足够长的生命周期

总结 ​

函数可以通过 impl Fn 或 Box<dyn Fn> 返回闭包。impl Fn 是静态分派,性能好但只能返回一种闭包;Box<dyn Fn> 是动态分派,可以根据条件返回不同闭包。返回闭包时几乎总是需要 move,因为闭包不能借用函数返回后就被释放的局部变量。返回闭包常用于工厂模式(根据参数创建不同行为)、策略模式(运行时选择算法)和管道模式(组合多个处理步骤)。根据闭包的行为可以返回 Fn(只读)、FnMut(可变)或 FnOnce(一次性)。