8.3 闭包与高阶函数
在 Rust 中，闭包和高阶函数是非常重要且强大的概念，它们使得 Rust 在处理函数式编程风格时非常灵活。闭包是可以捕获其环境中变量的匿名函数，而高阶函数是能够接收其他函数作为参数或返回函数的函数。
8.3.1 闭包（Closures）
闭包是 Rust 中的一类特殊函数，它不仅仅是代码块，而且可以捕获和访问外部作用域中的变量。闭包与普通函数的不同之处在于它们可以“捕获环境”中的变量，并在运行时访问这些变量。
闭包的基本语法
闭包的定义语法如下：
let closure_name = |参数| 表达式;
闭包的类型是由编译器推导出来的，可以在定义时使用 move 关键字来明确闭包的捕获方式。
闭包示例
fn main() {
let x = 5;
// 创建一个闭包，捕获 `x` 变量并返回 `x` 加上一个参数
let add_x = |y| x + y;
println!("Result: {}", add_x(10)); // 输出: Result: 15
}
- 上面的闭包
add_x捕获了外部的x变量，并与闭包的参数y一起返回一个计算结果。
闭包的类型推导
Rust 会根据闭包的使用方式自动推导闭包的类型。例如：
fn main() {
let multiply = |a, b| a * b; // 闭包自动推导类型
println!("{}", multiply(2, 3)); // 输出: 6
}
- 编译器会根据传入的参数类型自动推导闭包的类型。在这个例子中，闭包
multiply的类型被推导为fn(i32, i32) -> i32。
move 关键字
闭包默认会借用其捕获的变量。但如果你希望闭包获取变量的所有权并将其传递给闭包，可以使用 move 关键字。
fn main() {
let x = vec![1, 2, 3];
let print_vec = move || {
println!("{:?}", x); // 捕获并获取 x 的所有权
};
print_vec(); // 输出: [1, 2, 3]
// println!("{:?}", x); // 编译错误: x 的所有权已经转移
}
- 使用
move关键字后，闭包会获取x的所有权，导致原始的x无法再被使用。
8.3.2 闭包与函数签名
闭包在类型上可以与函数有一定的重叠，但它们并不是完全等价的。Rust 为闭包提供了三种不同的特征，分别是 Fn、FnMut 和 FnOnce。这些特征描述了闭包如何捕获其环境中的变量。
Fn：表示一个闭包，它可以多次调用，并且不会修改捕获的变量。适用于那些没有改变捕获变量的闭包。FnMut：表示一个可以修改捕获变量的闭包。它可以被调用多次，但每次调用时都可能修改其捕获的变量。FnOnce：表示一个只能调用一次的闭包，它会消耗捕获的变量。
函数签名示例
fn call_fn<F>(f: F) where F: Fn() {
f();
}
fn main() {
let closure = || println!("Hello, world!");
call_fn(closure); // 输出: Hello, world!
}
Fn特征用于表示那些不修改环境的闭包。
8.3.3 高阶函数（Higher-Order Functions）
高阶函数是指那些接受函数作为参数，或返回函数的函数。Rust 中的闭包和高阶函数使得函数式编程更加灵活和强大。
作为参数的高阶函数
fn apply<F>(f: F)
where
F: Fn(i32) -> i32,
{
let result = f(5);
println!("Result: {}", result);
}
fn main() {
let add_two = |x| x + 2;
apply(add_two); // 输出: Result: 7
}
apply是一个高阶函数，它接受一个实现了Fn(i32) -> i32特征的函数或闭包作为参数，并执行它。
作为返回值的高阶函数
高阶函数不仅可以接收函数作为参数，还可以返回函数。
fn multiplier(factor: i32) -> Box<dyn Fn(i32) -> i32> {
Box::new(move |x| x * factor) // 返回一个闭包
}
fn main() {
let multiply_by_3 = multiplier(3);
println!("{}", multiply_by_3(4)); // 输出: 12
}
multiplier是一个高阶函数，它返回一个闭包，闭包会根据传入的factor来计算值。
8.3.4 闭包与高阶函数的组合
闭包和高阶函数的组合使得 Rust 在处理函数式编程模式时非常灵活。例如，我们可以结合使用迭代器和闭包来进行数据变换：
fn main() {
let numbers = vec![1, 2, 3, 4, 5];
let result: Vec<i32> = numbers.into_iter()
.map(|x| x * 2)
.filter(|x| x > 5)
.collect();
println!("{:?}", result); // 输出: [6, 8, 10]
}
- 这里使用了
map闭包来乘以 2，再使用filter闭包来筛选出大于 5 的值，最后通过collect()收集结果。
8.3.5 闭包与迭代器适配器结合
闭包和迭代器适配器通常配合使用，特别是在数据处理和转换的场景中。闭包使得你能够灵活地定义操作，而迭代器适配器提供了方便的数据流操作。
fn main() {
let numbers = vec![1, 2, 3, 4, 5];
let sum: i32 = numbers.iter()
.map(|&x| x * x)
.filter(|&x| x > 10)
.sum();
println!("{}", sum); // 输出: 30
}
- 这里，我们使用了
map来对每个数字求平方，再通过filter进行筛选，最后通过sum计算总和。
8.3.6 小结
- 闭包 是 Rust 中的一个强大特性，它允许你创建可以捕获环境中变量的匿名函数，具有灵活的所有权和借用规则。
- 高阶函数 是接受或返回闭包的函数，它们使得函数的传递更加灵活。
- Rust 的闭包和高阶函数提供了强大的函数式编程支持，能够让我们在处理数据时实现复杂的转换、过滤和组合。
在下一节中，我们将继续探索 Rust 的错误处理机制，了解如何有效地管理错误并设计健壮的程序。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。