《Rust编程入门》8.3 闭包与高阶函数

8.3 闭包与高阶函数

在 Rust 中，闭包和高阶函数是非常重要且强大的概念，它们使得 Rust 在处理函数式编程风格时非常灵活。闭包是可以捕获其环境中变量的匿名函数，而高阶函数是能够接收其他函数作为参数或返回函数的函数。

8.3.1 闭包（Closures）

闭包是 Rust 中的一类特殊函数，它不仅仅是代码块，而且可以捕获和访问外部作用域中的变量。闭包与普通函数的不同之处在于它们可以“捕获环境”中的变量，并在运行时访问这些变量。

闭包的基本语法

闭包的定义语法如下：

1

let closure_name = |参数| 表达式;

闭包的类型是由编译器推导出来的，可以在定义时使用 move 关键字来明确闭包的捕获方式。

闭包示例

1
2
3
4
5
6
7
8

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 会根据闭包的使用方式自动推导闭包的类型。例如：

1
2
3
4

fn main() {
    let multiply = |a, b| a * b;  // 闭包自动推导类型
    println!("{}", multiply(2, 3));  // 输出: 6
}
  • 编译器会根据传入的参数类型自动推导闭包的类型。在这个例子中，闭包 multiply 的类型被推导为 fn(i32, i32) -> i32。

move 关键字

闭包默认会借用其捕获的变量。但如果你希望闭包获取变量的所有权并将其传递给闭包，可以使用 move 关键字。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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：表示一个只能调用一次的闭包，它会消耗捕获的变量。

函数签名示例

1
2
3
4
5
6
7
8

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 中的闭包和高阶函数使得函数式编程更加灵活和强大。

作为参数的高阶函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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 特征的函数或闭包作为参数，并执行它。

作为返回值的高阶函数

高阶函数不仅可以接收函数作为参数，还可以返回函数。

1
2
3
4
5
6
7
8

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 在处理函数式编程模式时非常灵活。例如，我们可以结合使用迭代器和闭包来进行数据变换：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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 闭包与迭代器适配器结合

闭包和迭代器适配器通常配合使用，特别是在数据处理和转换的场景中。闭包使得你能够灵活地定义操作，而迭代器适配器提供了方便的数据流操作。

1
2
3
4
5
6
7
8
9

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 的错误处理机制，了解如何有效地管理错误并设计健壮的程序。