Fn Trait 不可变借用 ​

核心概念 ​

Fn 是 Rust 中三个闭包 trait 之一,表示闭包只需要对捕获的变量进行不可变借用(&T)。实现了 Fn 的闭包可以被多次调用,并且可以在调用期间与外部共享被捕获变量的不可变引用。Fn 是最宽松的闭包 trait——它既可以多次调用,又不会修改环境,所以在需要回调、事件处理器等场景中最常用。Fn 是 FnMut 的子 trait,FnMut 是 FnOnce 的子 trait,因此实现了 Fn 的闭包自动实现 FnMut 和 FnOnce。

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

    // 这个闭包只读取 name 和 year,不修改,实现 Fn
    let info = || {
        println!("语言: {}, 年份: {}", name, year);
    };

    // Fn 闭包可以多次调用
    info();
    info();
    info();

    // 被捕获的变量在闭包存活期间仍可不可变借用
    println!("外部访问: {} {}", name, year);
}

Fn trait 的定义 ​

rust
// 标准库中 Fn 的简化定义:
// pub trait Fn<Args>: FnMut<Args> {
//     fn call(&self, args: Args) -> Self::Output;
// }

// 注意 &self:Fn 通过不可变引用调用自己
// 这意味着闭包不需要可变访问,可以共享引用

// 接受 Fn 闭包的函数
fn call_fn(f: &dyn Fn()) {
    f();  // 通过 &self 调用
}

fn call_fn_generic(f: impl Fn()) {
    f();
    f();  // 可以多次调用
}

fn main() {
    let msg = "hello";
    let greet = || println!("{}", msg);

    call_fn(&greet);
    call_fn_generic(greet);
}

三个闭包 trait 的关系 ​

rust
// Fn: FnMut: FnOnce 是继承关系
// 实现 Fn 的闭包自动实现 FnMut 和 FnOnce

fn needs_fn(f: impl Fn(i32) -> i32) -> i32 {
    f(10) + f(20)  // 多次不可变调用
}

fn needs_fn_mut(mut f: impl FnMut(i32) -> i32) -> i32 {
    f(10) + f(20)  // 可变调用
}

fn needs_fn_once(f: impl FnOnce(i32) -> i32) -> i32 {
    f(10)  // 只调用一次
}

fn main() {
    let factor = 3;
    let multiply = |x| x * factor;  // 只读 factor,实现 Fn

    // Fn 闭包可以传给任何一种参数
    println!("Fn: {}", needs_fn(multiply));
    println!("FnMut: {}", needs_fn_mut(multiply));
    println!("FnOnce: {}", needs_fn_once(multiply));
}
Traitself 参数可调用次数可修改环境实现条件
Fn&self无限次不能只读捕获
FnMut&mut self无限次可以可变捕获
FnOnceself一次可以按值捕获

Fn 作为函数参数 ​

rust
// 用 impl Fn 接受闭包(静态分派,性能好)
fn repeat_action(times: u32, action: impl Fn(u32)) {
    for i in 0..times {
        action(i);
    }
}

// 用 &dyn Fn 接受闭包(动态分派,灵活)
fn apply_formatter(items: &[i32], formatter: &dyn Fn(i32) -> String) -> Vec<String> {
    items.iter().map(|&x| formatter(x)).collect()
}

// 用 where 子句
fn process<F>(data: &[f64], transform: F) -> Vec<f64>
where
    F: Fn(f64) -> f64,
{
    data.iter().map(|&x| transform(x)).collect()
}

fn main() {
    // repeat_action
    let prefix = ">>>";
    repeat_action(3, |i| println!("{} 第{}次", prefix, i + 1));

    // apply_formatter
    let nums = vec![1, 2, 3, 4, 5];
    let hex = apply_formatter(&nums, &|x| format!("0x{:X}", x));
    println!("十六进制: {:?}", hex);

    let padded = apply_formatter(&nums, &|x| format!("{:>5}", x));
    println!("右对齐: {:?}", padded);

    // process
    let data = vec![1.0, 4.0, 9.0, 16.0, 25.0];
    let roots = process(&data, |x| x.sqrt());
    println!("平方根: {:?}", roots);

    let doubled = process(&data, |x| x * 2.0);
    println!("翻倍: {:?}", doubled);
}

存储 Fn 闭包 ​

rust
// 在结构体中存储 Fn 闭包
struct EventHandler<F: Fn(&str)> {
    handler: F,
    name: String,
}

impl<F: Fn(&str)> EventHandler<F> {
    fn new(name: &str, handler: F) -> Self {
        EventHandler {
            handler,
            name: name.to_string(),
        }
    }

    fn trigger(&self, event: &str) {
        println!("[{}] 触发事件:", self.name);
        (self.handler)(event);  // 通过 &self 调用,闭包是 Fn
    }
}

fn main() {
    let prefix = String::from("LOG");

    // Fn 闭包可以存储并多次调用
    let handler = EventHandler::new("日志处理器", |event| {
        println!("  事件: {}", event);
    });

    handler.trigger("用户登录");
    handler.trigger("数据查询");
    handler.trigger("用户登出");

    // 使用 trait 对象存储不同的 Fn 闭包
    let handlers: Vec<Box<dyn Fn(&str)>> = vec![
        Box::new(|e| println!("  处理器A: {}", e)),
        Box::new(|e| println!("  处理器B: {}", e.to_uppercase())),
        Box::new(|e| println!("  处理器C: 长度={}", e.len())),
    ];

    println!("\n广播事件:");
    for (i, handler) in handlers.iter().enumerate() {
        print!("[{}]", i);
        handler("测试消息");
    }
}

基本示例 ​

用 Fn trait 构建一个可配置的数据验证管道:

rust
struct Validator {
    name: String,
    rules: Vec<Box<dyn Fn(&str) -> Result<(), String>>>,
}

impl Validator {
    fn new(name: &str) -> Self {
        Validator {
            name: name.to_string(),
            rules: Vec::new(),
        }
    }

    // 添加验证规则(Fn 闭包)
    fn add_rule<F>(&mut self, rule: F)
    where
        F: Fn(&str) -> Result<(), String> + 'static,
    {
        self.rules.push(Box::new(rule));
    }

    // 运行所有规则
    fn validate(&self, input: &str) -> Vec<String> {
        let mut errors = Vec::new();
        for rule in &self.rules {
            if let Err(msg) = rule(input) {
                errors.push(msg);
            }
        }
        errors
    }

    fn is_valid(&self, input: &str) -> bool {
        self.validate(input).is_empty()
    }
}

fn main() {
    let mut username_validator = Validator::new("用户名");

    // 每个规则都是 Fn 闭包,可以多次调用
    username_validator.add_rule(|s| {
        if s.is_empty() {
            Err(String::from("不能为空"))
        } else {
            Ok(())
        }
    });

    username_validator.add_rule(|s| {
        if s.len() < 3 {
            Err(format!("长度不能少于3,当前长度: {}", s.len()))
        } else {
            Ok(())
        }
    });

    username_validator.add_rule(|s| {
        if s.len() > 20 {
            Err(format!("长度不能超过20,当前长度: {}", s.len()))
        } else {
            Ok(())
        }
    });

    let min_len = 3;
    username_validator.add_rule(move |s| {
        if s.chars().all(|c| c.is_alphanumeric() || c == '_') {
            Ok(())
        } else {
            Err(String::from("只能包含字母、数字和下划线"))
        }
    });

    // 测试多个输入
    let test_cases = vec!["", "ab", "admin", "hello world", "valid_user_123",
        "this_is_a_very_long_username_that_exceeds_limit"];

    println!("=== {} 验证 ===", username_validator.name);
    for input in test_cases {
        let errors = username_validator.validate(input);
        if errors.is_empty() {
            println!("  '{}' → 通过", input);
        } else {
            println!("  '{}' → 失败:", input);
            for err in &errors {
                println!("    - {}", err);
            }
        }
    }
}

常见问题 ​

问题一:怎么判断闭包实现了 Fn 而不是 FnMut?

如果闭包体中没有修改任何捕获的变量,也没有消耗(move + drop)任何变量,就实现 Fn。简单判断:闭包里只有读操作。

问题二:函数参数写 impl Fn 还是 impl FnOnce?

如果函数内需要多次调用闭包,用 Fn 或 FnMut。如果只调用一次,用 FnOnce 最宽松——它可以接受所有三种闭包。一般原则:要求越少越好。

问题三:Fn 闭包可以并发使用吗?

Fn 闭包通过 &self 调用,多个不可变引用可以共存,所以理论上可以在多线程中共享(如果闭包还实现了 Send + Sync)。

问题四:普通函数实现 Fn 吗?

是的。普通函数和函数指针(fn)自动实现 Fn、FnMut 和 FnOnce。

适用场景 ​

  • 回调函数:事件处理器、钩子函数
  • 验证规则:可重复执行的检查逻辑
  • 策略模式:可替换的算法/行为
  • 迭代器方法:map、filter、for_each 等

注意事项 ​

  • Fn 闭包通过 &self 调用,不能修改捕获的变量
  • 实现 Fn 的闭包自动实现 FnMut 和 FnOnce
  • 参数类型选择 Fn 时要求最严格,调用者的闭包必须是只读的
  • 普通函数和函数指针自动实现 Fn
  • 存储多个不同的 Fn 闭包需要用 Box<dyn Fn>
  • Fn 闭包可以安全地共享不可变引用

总结 ​

Fn trait 表示闭包只对捕获的变量进行不可变借用,通过 &self 调用。这意味着 Fn 闭包可以被多次调用,并且不会修改外部环境。Fn 是 FnMut 的子 trait,实现了 Fn 的闭包自动实现 FnMut 和 FnOnce。在需要多次调用且不修改状态的场景(回调、验证规则、迭代器方法)中使用 Fn。存储多个不同的 Fn 闭包时使用 Box<dyn Fn>。普通函数和函数指针也实现了 Fn。