Scala 函数式编程：高阶函数与闭包

在 Scala 中，函数是一等公民，这意味着函数可以像变量一样被传递和操作。掌握高阶函数和闭包是编写简洁、可维护代码的关键。

1. 理解并使用高阶函数

高阶函数是指能够接收其他函数作为参数，或者返回一个函数的函数。这允许我们将通用的逻辑（如遍历、过滤）与具体的业务逻辑（如计算、判断）分离开来。

定义一个接收函数参数的方法。

打开 Scala 编辑器或 REPL，输入以下代码定义一个高阶函数，该函数接收一个整数 x 和一个函数 f，将 f 作用于 x：

// 定义一个高阶函数
def applyOperation(x: Int, f: Int => Int): Int = {
  f(x)
}

定义具体的业务逻辑函数。

def square(n: Int): Int = n * n
def increment(n: Int): Int = n + 1

调用高阶函数。

将 square 或 increment 作为参数传递给 applyOperation：

val result1 = applyOperation(5, square)  // 结果为 25
val result2 = applyOperation(5, increment) // 结果为 6

2. 掌握常用集合高阶函数

Scala 集合类（如 List）提供了大量内置的高阶函数，用于处理数据流。

2.1 使用 map 转换数据

map 函数会将集合中的每一个元素应用于给定的函数，并返回一个新的集合。

创建一个列表。

val numbers = List(1, 2, 3, 4)

调用 map 函数，将每个元素乘以 2。

val doubled = numbers.map(n => n * 2)
// 或者使用下划线简写：val doubled = numbers.map(_ * 2)

此时 doubled 的值为 List(2, 4, 6, 8)。

2.2 使用 filter 筛选数据

filter 函数根据给定的布尔条件（返回 Boolean 的函数）保留元素。

调用 filter 函数，保留偶数。

val evens = numbers.filter(_ % 2 == 0)

此时 evens 的值为 List(2, 4)。

2.3 使用 reduce 聚合数据

reduce 函数接收一个二元函数，将集合中的元素两两结合，最终聚合为一个结果。

调用 reduce 函数，计算列表的和。

val sum = numbers.reduce((a, b) => a + b)
// 或者使用下划线简写：val sum = numbers.reduce(_ + _)

此时 sum 的值为 10。

为了更直观地理解 reduce 的执行流程，我们可以参考以下步骤：

3. 深入理解闭包

闭包是指一个函数，它依赖于定义在函数外部的一个或多个变量。即使在外部变量超出作用域后，该函数仍然可以访问和修改这些变量。

编写一个闭包示例。

定义一个返回函数的函数 makeMultiplier：

def makeMultiplier(factor: Int): Int => Int = {
  // factor 是外部变量，被内部函数捕获
  (x: Int) => x * factor
}

创建特定的乘法函数。

val timesThree = makeMultiplier(3)
val timesTen = makeMultiplier(10)

调用生成的函数。

val res1 = timesThree(5)  // 结果为 15
val res2 = timesTen(5)    // 结果为 50

在这个过程中，timesThree 函数“记住了”创建它时的 factor 值（即 3）。即使 makeMultiplier 函数已经执行完毕，factor 变量依然存在于 timesThree 的闭包环境中。

4. 函数柯里化与部分应用

柯里化是将接收多个参数的函数转换为一系列只接收一个参数的函数的过程。这在配置特定参数时非常有用。

定义一个普通的两参数函数。

def add(x: Int, y: Int): Int = x + y

将其转换为柯里化形式。

def addCurried(x: Int)(y: Int): Int = x + y

使用部分应用函数。

如果我们想固定一个参数，例如总是加 10：

val addTen = addCurried(10) _ // 这里的 _ 表示剩余的参数列表

现在 addTen 是一个 Int => Int 的函数：

val result = addTen(5) // 结果为 15

5. 实战案例：数据处理流水线

结合上述知识，构建一个简单的数据处理流水线：过滤奇数、转换为平方、求和。

定义原始数据。

val data = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

构建处理链。

val processResult = data
  .filter(_ % 2 == 0)    // 筛选出偶数: 2, 4, 6, 8, 10
  .map(x => x * x)       // 计算平方: 4, 16, 36, 64, 100
  .reduce(_ + _)         // 求和

查看结果。

println(processResult)  // 输出 220

下表总结了上述流水线中每个步骤的变化：