Fn Trait 不可变借用
核心概念
Fn 是 Rust 中三个闭包 trait 之一,表示闭包只需要对捕获的变量进行不可变借用(&T)。实现了 Fn 的闭包可以被多次调用,并且可以在调用期间与外部共享被捕获变量的不可变引用。Fn 是最宽松的闭包 trait——它既可以多次调用,又不会修改环境,所以在需要回调、事件处理器等场景中最常用。Fn 是 FnMut 的子 trait,FnMut 是 FnOnce 的子 trait,因此实现了 Fn 的闭包自动实现 FnMut 和 FnOnce。
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 的定义
// 标准库中 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 的关系
// 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));
}| Trait | self 参数 | 可调用次数 | 可修改环境 | 实现条件 |
|---|---|---|---|---|
Fn | &self | 无限次 | 不能 | 只读捕获 |
FnMut | &mut self | 无限次 | 可以 | 可变捕获 |
FnOnce | self | 一次 | 可以 | 按值捕获 |
Fn 作为函数参数
// 用 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 闭包
// 在结构体中存储 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 构建一个可配置的数据验证管道:
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。