高阶函数概念
什么是高阶函数
高阶函数是指接受函数作为参数或返回函数的函数。在 Rust 中,高阶函数通过函数指针(fn)或闭包 trait(Fn、FnMut、FnOnce)来实现。标准库中大量使用高阶函数,比如迭代器的 map、filter、fold 等。
rust
fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// map 是高阶函数:接受一个闭包作为参数
let squares: Vec<i32> = numbers.iter().map(|&x| x * x).collect();
println!("平方:{:?}", squares);
// filter 是高阶函数:接受一个返回 bool 的闭包
let evens: Vec<&i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
println!("偶数:{:?}", evens);
// fold 是高阶函数:接受初始值和一个累积闭包
let sum = numbers.iter().fold(0, |acc, &x| acc + x);
println!("总和:{}", sum);
}接受函数作为参数
rust
// 用函数指针作为参数
fn apply_twice(f: fn(i32) -> i32, value: i32) -> i32 {
f(f(value))
}
// 用泛型 + Fn trait 作为参数(更通用,能接受闭包)
fn apply_twice_generic<F: Fn(i32) -> i32>(f: F, value: i32) -> i32 {
f(f(value))
}
// 用 impl Fn 作为参数(语法更简洁)
fn transform(data: &[i32], f: impl Fn(i32) -> i32) -> Vec<i32> {
data.iter().map(|&x| f(x)).collect()
}
fn double(n: i32) -> i32 { n * 2 }
fn main() {
// 传函数指针
println!("apply_twice(double, 3) = {}", apply_twice(double, 3)); // 12
// 传闭包
println!("{}", apply_twice_generic(|x| x + 10, 5)); // 25
// 传捕获环境的闭包
let factor = 3;
let result = transform(&[1, 2, 3, 4], |x| x * factor);
println!("变换后:{:?}", result); // [3, 6, 9, 12]
}三种闭包 trait
Rust 用三个 trait 来描述闭包的行为,区别在于如何使用捕获的变量。
| Trait | 签名 | 含义 | 适用场景 |
|---|---|---|---|
Fn | &self | 不可变借用捕获的变量 | 可以多次调用,不修改状态 |
FnMut | &mut self | 可变借用捕获的变量 | 可以多次调用,会修改状态 |
FnOnce | self | 获取捕获变量的所有权 | 只能调用一次 |
rust
// Fn:不修改捕获的变量
fn call_fn(f: impl Fn() -> String) -> String {
let a = f(); // 第一次调用
let b = f(); // 第二次调用——可以多次调用
format!("{} & {}", a, b)
}
// FnMut:修改捕获的变量
fn call_fn_mut(mut f: impl FnMut() -> i32) -> Vec<i32> {
vec![f(), f(), f()] // 每次调用状态都可能变
}
// FnOnce:消耗捕获的变量,只能调用一次
fn call_fn_once(f: impl FnOnce() -> String) -> String {
f() // 只能调用一次
// f() // 编译错误:已经被消耗了
}
fn main() {
// Fn 示例
let name = String::from("Rust");
let result = call_fn(|| format!("Hello, {}", name));
println!("{}", result);
// FnMut 示例
let mut counter = 0;
let counts = call_fn_mut(|| { counter += 1; counter });
println!("计数:{:?}", counts); // [1, 2, 3]
// FnOnce 示例
let data = String::from("一次性数据");
let result = call_fn_once(|| data); // data 的所有权移入闭包
println!("{}", result);
}返回函数
函数可以返回闭包,但因为闭包的大小在编译期不确定,需要用 Box<dyn Fn> 或 impl Fn 来返回。
rust
// 用 impl Fn 返回闭包(只能返回同一种闭包)
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
move |x| x + n // move 把 n 的所有权移入闭包
}
// 用 Box<dyn Fn> 返回闭包(可以返回不同的闭包)
fn make_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),
_ => Box::new(|a, b| a + b),
}
}
fn main() {
// impl Fn 返回
let add5 = make_adder(5);
let add10 = make_adder(10);
println!("add5(3) = {}", add5(3)); // 8
println!("add10(3) = {}", add10(3)); // 13
// Box<dyn Fn> 返回
let op = make_operation("mul");
println!("mul(4, 5) = {}", op(4, 5)); // 20
}函数组合
高阶函数的强大之处在于可以组合多个函数形成新功能。
rust
// 组合两个函数:先执行 f,再执行 g
fn compose<F, G>(f: F, g: G) -> impl Fn(i32) -> i32
where
F: Fn(i32) -> i32,
G: Fn(i32) -> i32,
{
move |x| g(f(x))
}
// 管道:依次应用一系列函数
fn pipeline(value: i32, functions: &[fn(i32) -> i32]) -> i32 {
let mut result = value;
for &f in functions {
result = f(result);
}
result
}
fn double(n: i32) -> i32 { n * 2 }
fn add_one(n: i32) -> i32 { n + 1 }
fn square(n: i32) -> i32 { n * n }
fn main() {
// 函数组合
let double_then_add = compose(double, add_one);
println!("double_then_add(5) = {}", double_then_add(5)); // 11
let add_then_double = compose(add_one, double);
println!("add_then_double(5) = {}", add_then_double(5)); // 12
// 管道
let result = pipeline(3, &[double, add_one, square]);
println!("pipeline(3, [double, add_one, square]) = {}", result); // 49
// 3 -> double -> 6 -> add_one -> 7 -> square -> 49
}基本示例
用高阶函数实现数据处理管道:
rust
struct DataProcessor {
data: Vec<f64>,
}
impl DataProcessor {
fn new(data: Vec<f64>) -> Self {
DataProcessor { data }
}
// 高阶方法:对每个元素应用变换
fn map_all(&self, f: impl Fn(f64) -> f64) -> DataProcessor {
DataProcessor {
data: self.data.iter().map(|&x| f(x)).collect(),
}
}
// 高阶方法:过滤元素
fn filter_all(&self, predicate: impl Fn(f64) -> bool) -> DataProcessor {
DataProcessor {
data: self.data.iter().filter(|&&x| predicate(x)).copied().collect(),
}
}
// 高阶方法:折叠归约
fn reduce(&self, init: f64, f: impl Fn(f64, f64) -> f64) -> f64 {
self.data.iter().fold(init, |acc, &x| f(acc, x))
}
fn values(&self) -> &[f64] {
&self.data
}
}
fn main() {
let processor = DataProcessor::new(vec![1.0, -2.5, 3.7, -4.1, 5.0, 6.3, -1.8]);
// 链式调用高阶方法
let result = processor
.filter_all(|x| x > 0.0) // 只保留正数
.map_all(|x| x * 2.0) // 翻倍
.map_all(|x| (x * 10.0).round() / 10.0); // 保留一位小数
println!("处理后:{:?}", result.values());
// 求和
let sum = processor
.filter_all(|x| x > 0.0)
.reduce(0.0, |acc, x| acc + x);
println!("正数总和:{:.1}", sum);
}常见问题
问题一:参数写 fn 还是 impl Fn?
| 写法 | 接受范围 | 适用场景 |
|---|---|---|
fn(T) -> R | 只接受函数指针 | 不需要闭包 |
impl Fn(T) -> R | 函数指针和闭包都行 | 通用场景,推荐 |
&dyn Fn(T) -> R | 动态分发 | 需要存储不同类型的闭包 |
Box<dyn Fn(T) -> R> | 堆分配的动态闭包 | 返回闭包或存储在集合中 |
问题二:什么时候用 Fn、FnMut、FnOnce?
从宽松到严格:FnOnce > FnMut > Fn。如果你的高阶函数只调用参数一次,用 FnOnce;需要多次调用且可能修改状态,用 FnMut;多次调用且不修改状态,用 Fn。不确定时从 FnOnce 开始,编译器会告诉你是否需要更严格的约束。
问题三:为什么返回闭包需要 move?
如果闭包捕获了函数的局部变量,函数返回后局部变量就不存在了。move 把变量的所有权转移到闭包中,让闭包拥有这些数据,这样闭包就可以在函数返回后继续使用这些数据。
适用场景
- 迭代器处理:
map、filter、fold等 - 回调机制:事件处理、异步操作完成时的回调
- 策略模式:运行时选择不同的算法
- 函数工厂:根据参数生成定制的函数
- 数据处理管道:链式组合多个变换操作
注意事项
- 接受闭包参数优先用
impl Fn而不是fn类型 - 返回闭包时需要
impl Fn或Box<dyn Fn> - 闭包捕获局部变量时返回需要加
move Fn是FnMut的子集,FnMut是FnOnce的子集- 高阶函数配合迭代器是 Rust 函数式编程的核心
- 过度使用高阶函数可能降低可读性,适度使用
总结
高阶函数是接受函数作为参数或返回函数的函数。Rust 通过函数指针 fn 和闭包 trait(Fn、FnMut、FnOnce)来支持高阶函数。接受函数参数时推荐用 impl Fn 语法(兼容函数指针和闭包),返回闭包时用 impl Fn(单一类型)或 Box<dyn Fn>(多种类型)。高阶函数在迭代器处理、回调机制、策略模式和数据处理管道中应用广泛,是 Rust 函数式编程风格的基础。