函数式编程：高阶函数与闭包讲座

欢迎来到函数式编程的世界！ 🌟

大家好，欢迎来到今天的讲座！今天我们要探讨的是函数式编程中的两个重要概念：高阶函数和闭包。如果你对这两个词感到陌生，别担心，我们会用轻松诙谐的语言，结合代码示例，帮助你快速理解它们的精髓。准备好了吗？让我们开始吧！

什么是函数式编程？

在进入正题之前，先简单介绍一下函数式编程（Functional Programming, FP）。FP是一种编程范式，它将计算视为数学函数的求值过程，并避免了可变数据和副作用。FP的核心思想是“一切皆为函数”，也就是说，程序中的所有操作都可以通过函数来表达。

FP的好处有很多，比如代码更简洁、更容易测试、并行化处理更方便等。但今天我们不深入讨论这些，而是聚焦于两个关键概念：高阶函数和闭包。

高阶函数：函数也能当参数？ 😲

1. 什么是高阶函数？

在函数式编程中，函数不仅仅是用来执行某些操作的工具，它们还可以作为参数传递给其他函数，或者作为返回值从函数中返回。这样的函数被称为高阶函数（Higher-Order Function）。

换句话说，如果一个函数接受另一个函数作为参数，或者返回一个函数作为结果，那么这个函数就是高阶函数。听起来有点抽象？别急，我们来看几个例子。

2. 高阶函数的例子

例 1：`map` 函数

map 是最常见的高阶函数之一。它的作用是对一个数组中的每个元素应用一个函数，并返回一个新的数组。假设我们有一个数组 [1, 2, 3]，我们想将每个元素乘以 2：

const numbers = [1, 2, 3];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // 输出: [2, 4, 6]

在这个例子中，map 是一个高阶函数，因为它接受了一个匿名函数 x => x * 2 作为参数，并将其应用于数组的每个元素。

例 2：`filter` 函数

filter 另一个常见的高阶函数，它用于筛选数组中的元素。假设我们有一个数组 [1, 2, 3, 4, 5]，我们只想保留其中的偶数：

const numbers = [1, 2, 3, 4, 5];
const evens = numbers.filter(x => x % 2 === 0);
console.log(evens); // 输出: [2, 4]

filter 也是一个高阶函数，因为它接受了一个匿名函数 x => x % 2 === 0 作为参数，用于判断哪些元素应该被保留。

例 3：自定义高阶函数

我们不仅可以使用内置的高阶函数，还可以自己编写高阶函数。例如，我们可以创建一个函数 applyTwice，它接受一个函数 f 和一个参数 x，并将 f 应用两次：

function applyTwice(f, x) {
  return f(f(x));
}

// 定义一个简单的函数
function addOne(n) {
  return n + 1;
}

console.log(applyTwice(addOne, 5)); // 输出: 7 (5 -> 6 -> 7)

在这个例子中，applyTwice 是一个高阶函数，因为它接受了一个函数 addOne 作为参数，并将其应用两次。

闭包：函数还能记住东西？ 😮

1. 什么是闭包？

闭包（Closure）是函数式编程中的另一个重要概念。简单来说，闭包是一个函数，它不仅包含自己的代码，还“记住”了它被定义时的环境。换句话说，闭包可以访问它所在的作用域中的变量，即使这些变量在其外部作用域中已经不再可用。

这听起来有点神奇，对吧？实际上，闭包在很多编程语言中都有广泛的应用，尤其是在 JavaScript 中。

2. 闭包的例子

例 1：基本的闭包

假设我们有一个函数 createCounter，它返回一个计数器函数。每次调用这个计数器函数时，它都会返回一个递增的数字：

function createCounter() {
  let count = 0;
  return function() {
    count += 1;
    return count;
  };
}

const counter = createCounter();
console.log(counter()); // 输出: 1
console.log(counter()); // 输出: 2
console.log(counter()); // 输出: 3

在这个例子中，createCounter 返回了一个闭包。这个闭包“记住”了 count 变量，即使 createCounter 已经执行完毕，count 仍然可以在闭包中被访问和修改。

例 2：多个闭包共享同一个环境

闭包不仅仅能记住局部变量，它们还可以共享同一个环境。假设我们有多个计数器，它们都来自同一个 createCounter 函数：

function createCounter() {
  let count = 0;
  return function() {
    count += 1;
    return count;
  };
}

const counter1 = createCounter();
const counter2 = createCounter();

console.log(counter1()); // 输出: 1
console.log(counter1()); // 输出: 2
console.log(counter2()); // 输出: 1
console.log(counter2()); // 输出: 2

在这个例子中，counter1 和 counter2 是两个独立的闭包，它们各自维护着自己的 count 变量。因此，它们不会互相影响。

例 3：闭包与回调函数

闭包经常与回调函数一起使用。假设我们有一个 setTimeout 函数，它会在一段时间后执行一个回调函数。我们可以利用闭包来保存一些状态信息：

function setupTimeout(message, delay) {
  return function() {
    console.log(message);
  };
}

const delayedMessage = setupTimeout("Hello, world!", 2000);
setTimeout(delayedMessage, 2000); // 2秒后输出: "Hello, world!"

在这个例子中，setupTimeout 返回了一个闭包，这个闭包“记住”了 message 参数。即使 setupTimeout 已经执行完毕，delayedMessage 仍然可以访问 message。

高阶函数与闭包的结合：威力加倍！ 💥

高阶函数和闭包结合起来，可以让我们的代码更加灵活和强大。举个例子，假设我们想创建一个函数工厂，它可以生成不同类型的过滤器函数。我们可以使用高阶函数和闭包来实现这一点：

function createFilter(minValue) {
  return function(value) {
    return value >= minValue;
  };
}

const filterAbove10 = createFilter(10);
const numbers = [5, 10, 15, 20];

const filteredNumbers = numbers.filter(filterAbove10);
console.log(filteredNumbers); // 输出: [10, 15, 20]

在这个例子中，createFilter 是一个高阶函数，它返回了一个闭包。这个闭包“记住”了 minValue 参数，并在每次调用时使用它来过滤数组中的元素。

总结：高阶函数与闭包的魔力 ✨

通过今天的讲座，我们了解了函数式编程中的两个重要概念：高阶函数和闭包。高阶函数让我们可以将函数作为参数传递或返回，而闭包则让我们可以创建具有持久状态的函数。这两者的结合，使得我们的代码更加简洁、灵活和强大。

希望今天的讲解对你有所帮助！如果你还有任何疑问，欢迎随时提问。下次见！👋

参考资料

《JavaScript: The Good Parts》 by Douglas Crockford
《Eloquent JavaScript》 by Marijn Haverbeke
《You Don’t Know JS》 by Kyle Simpson

这些书籍都对函数式编程、高阶函数和闭包有非常详细的解释，推荐阅读！