高阶函数：函数为何能作为参数和返回值？

——基于闭包与 [[Environment]] 的能力，实现函数的组合与抽象

“函数能作为值传递，是编程语言从‘工具箱’迈向‘代数系统’的成人礼。”

一、什么是高阶函数？——不仅仅是“函数当参数”

定义： 高阶函数（Higher-Order Function）是满足以下任一条件的函数：

1. 接受一个或多个函数作为参数
2. 返回一个函数作为返回值

但这只是表象。
真正的本质是：

函数在语言中是“第一类公民”（First-Class Citizen）

这意味着函数可以像数字、字符串一样：

• 被赋值给变量
• 作为参数传递
• 作为返回值
• 存储在数据结构中

二、JavaScript 的底层机制：[[Environment]] 与闭包

为什么 JS 能支持高阶函数？
答案藏在 执行上下文（Execution Context） 和 词法环境（Lexical Environment） 中。

1. [[Environment]]：函数的“记忆体”

每个函数在创建时，都会被赋予一个内部属性 [[Environment]]，它指向函数定义时所处的词法环境。

function outer() {
  const x = 10;
  
  function inner() {
    return x; // inner.[[Environment]] 指向 outer 的词法环境
  }
  
  return inner;
}

当 inner 被返回时，它携带了 [[Environment]]，因此能“记住” x。

这就是闭包（Closure） 的实现机制。

2. 闭包：高阶函数的“能量源”

闭包让函数能：

• 捕获外部变量
• 延迟计算
• 封装状态（而不暴露全局）

示例：函数工厂

function makeAdder(n) {
  return function(x) {
    return x + n; // n 来自外层作用域，被闭包捕获
  };
}

const add5 = makeAdder(5);
add5(3); // 8

makeAdder(5) 返回的函数，其 [[Environment]] 中保存了 n = 5。

闭包让“函数返回函数”成为可能，且返回的函数能记住创建时的环境。

三、高阶函数的两大核心能力

能力 1：接受函数作为参数 —— 行为参数化

你不再传递数据，而是传递“行为”。

经典案例：Array.prototype.map

[1, 2, 3].map(function(x) { return x * 2; });

map 不关心“乘以 2”这个逻辑，它只关心：

• 遍历数组
• 对每个元素调用你传入的函数
• 收集结果

map 是一个“算法模板”，你通过参数注入具体行为。

能力 2：返回函数 —— 创建定制化行为

返回的函数可以：

• 捕获参数（柯里化）
• 封装配置（中间件）
• 延迟执行（thunk）

示例：通用比较器

function sortBy(key) {
  return (a, b) => a[key] - b[key];
}

const sortByName = sortBy('name');
const sortByAge = sortBy('age');

users.sort(sortByAge);

sortBy 返回一个已配置好排序键的比较函数。
这就是抽象的升华：你抽象出了“按某字段排序”这一模式。

四、高阶函数如何实现“组合”与“抽象”？

1. 组合（Composition）—— 函数的“乐高”

function compose(f, g) {
  return function(x) {
    return f(g(x));
  };
}

const toUpper = s => s.toUpperCase();
const exclaim = s => s + '!';
const shout = compose(exclaim, toUpper);

shout('hello'); // 'HELLO!'

compose 是一个高阶函数，它接受两个函数，返回一个新的函数。
它把函数变成了可组合的代数对象。

2. 抽象（Abstraction）—— 封装通用模式

抽象“重试逻辑”

function withRetry(times, action) {
  return async function(...args) {
    for (let i = 0; i < times; i++) {
      try {
        return await action(...args);
      } catch (e) {
        if (i === times - 1) throw e;
      }
    }
  };
}

const fetchWithRetry = withRetry(3, fetch);

withRetry 抽象了“失败重试”这一横切关注点。
你可以在任何异步函数上应用它。

五、闭包的“黑暗面”：内存泄漏风险

闭包虽强大，但可能造成内存泄漏：

function heavyComponent() {
  const bigData = new Array(1000000).fill('payload');
  
  return {
    getName: () => 'Component',
    // 只要 getName 存在，bigData 就不会被 GC
  };
}

getName 的 [[Environment]] 包含 bigData，即使它用不到。
闭包引用的变量不会被垃圾回收。

解决方案：

• 避免在返回函数中引用大对象
• 显式释放引用：bigData = null

六、工程实践：写出优雅的高阶函数

1. 柯里化（Currying）—— 参数的渐进式绑定

const add = a => b => a + b;
const add5 = add(5);
add5(3); // 8

柯里化是高阶函数 + 闭包的完美体现。

2. 中间件模式（Express/Koa）

function logger(store) {
  return next => action => {
    console.log('dispatch:', action);
    return next(action);
  };
}

中间件是高阶函数的链式组合，实现关注点分离。

3. 装饰器（Decorator）

function memoize(fn) {
  const cache = new Map();
  return arg => {
    if (cache.has(arg)) return cache.get(arg);
    const result = fn(arg);
    cache.set(arg, result);
    return result;
  };
}

const fib = memoize(n => n <= 1 ? n : fib(n-1) + fib(n-2));

memoize 抽象了“缓存”逻辑，可复用于任何纯函数。

结语：高阶函数是“函数式编程的引擎”

它让函数从“执行单元”升格为“可操作的数据”。

通过 [[Environment]] 和闭包，JS 赋予了函数：

• 记忆能力（捕获环境）
• 组合能力（返回函数）
• 抽象能力（参数化行为）

这才是 map、filter、compose 等工具得以存在的根本原因。