柯里化：用闭包编织参数的函数流水线

有意义
75 阅读5分钟

什么是柯里化？

柯里化（Currying）是一种函数转换技术：它把一个原本需要多个参数的函数，变成一连串只接收单个参数的函数。每次调用只传入一个参数，并返回一个新的函数用于接收下一个参数，直到所有参数都收集完毕，才真正执行原始逻辑并返回最终结果。

这听起来像是语法游戏，但实际上，它是 JavaScript 函数式编程中一项强大而实用的能力，其背后依赖的是我们已经熟悉的机制：闭包、词法作用域，以及“函数可以被返回”的特性。

为了清晰理解这一过程，我们可以从最基础的例子开始，逐步深入到通用实现和实际应用。

从普通函数说起

最开始，我们有一个再普通不过的加法函数：

// 1.js - 普通函数（对比基础）
function add(a, b) {
  return a + b;
}
console.log(add(1, 2)); // 输出：3

image.png 这个函数要求我们在一次调用中提供全部参数。这种方式简单直接，但也意味着灵活性有限——如果我们只想先确定第一个数，稍后再决定第二个数，就无能为力了。

手动柯里化：拆解参数

于是我们尝试手动改造它：

// 2.js - 手动柯里化（基础示例）
function add(a) {
  return function(b) {
    return a + b;
  };
}
console.log(add(1)(2)); // 输出：3

image.png 现在，add 不再直接计算结果，而是先接收 a，返回一个新函数；这个新函数“记住”了 a 的值，并等待 b 的到来。当我们写下 add(1)(2) 时，实际上经历了两个步骤：

  1. add(1) 执行，创建一个局部作用域，其中 a = 1，然后返回内部函数 function(b) { return 1 + b }；
  2. 紧接着调用这个返回的函数，传入 2，此时内层函数通过词法作用域访问外层的 a，完成计算。

这里的关键在于：即使 add(1) 的执行上下文已经销毁，内部函数依然能访问 a——这正是闭包的作用。柯里化的第一步，本质上就是利用闭包来“暂存”已传入的参数。

通用柯里化：自动处理任意函数

手动为每个函数写柯里化版本显然不现实。我们需要一个通用工具，能自动将任意固定参数数量的函数转换为柯里化形式。

// 3.js - 通用柯里化函数（核心实现）
function add(a, b) {
  return a + b;
}

function curry(fn) {
  return function curried(...args) {
    // 如果已传参数数量 >= 原函数所需参数数量，立即执行
    if (args.length >= fn.length) {
      return fn(...args);
    }
    // 否则返回一个新函数，继续收集剩余参数
    return (...rest) => curried(...args, ...rest);
  };
}

const curriedAdd = curry(add);
console.log(curriedAdd(1)(2)); // 输出：3

image.png 这个 curry 函数的巧妙之处在于：

  • 它利用 fn.length 获取原函数声明时的形参个数（例如 add.length 是 2）；
  • 返回的 curried 函数通过闭包捕获了 fn 这个自由变量；
  • 每次调用都用 ...args 累积已传参数，若还不够，就返回一个箭头函数继续等待更多参数；
  • 一旦参数数量达标，就调用原始函数并返回结果。

执行流程如下：

  • curriedAdd(1) → args = [1]，长度小于 2，返回 (...rest) => curried(1, ...rest)；
  • curriedAdd(1)(2) → rest = [2]，合并为 [1, 2]，满足条件，执行 add(1, 2)，返回 3。

整个过程像一条由闭包维系的参数链，每一步都依赖前一步留下的上下文，直到最终触发计算。

实际应用：提升语义与复用性

柯里化的真正价值，在于它能让我们预设部分参数，从而创建更具表达力的专用函数。

// 4.js - 柯里化的实际应用（固定参数）
const log = type => message => {
  console.log(`[${type}]: ${message}`);
};

const errorLog = log("ERROR");
const infoLog = log("INFO");

errorLog("接口异常");     // [ERROR]: 接口异常
infoLog("页面加载完成");   // [INFO]: 页面加载完成

image.png 这里，log 是一个天然柯里化的函数。我们先传入日志类型（如 "ERROR"），得到一个专门记录错误的函数 errorLog。后续使用时，只需关心具体消息，无需重复指定类型。

这种模式带来了多重好处：

  • 代码复用：一个通用函数可派生出多个专用版本；
  • 语义清晰：errorLog("xxx") 比 log("ERROR", "xxx") 更直观，意图一目了然；
  • 参数解耦：配置（如日志类型）与数据（如错误信息）分离，便于维护和测试。

类似思路也广泛应用于 API 封装、事件处理器定制、中间件组合等场景。

回到本质：柯里化为何可行？

归根结底，柯里化之所以能在 JavaScript 中自然实现，是因为语言本身提供了三大支柱：

  1. 函数是一等公民：可以被赋值、返回、作为参数传递；
  2. 词法作用域：函数在定义时就确定了变量查找范围；
  3. 闭包：让函数即使在其定义环境销毁后，仍能访问外部变量。

柯里化不是凭空创造的新概念，而是这些机制协同作用下的自然产物。它把“参数传递”从一次性动作，转变为一种可组合、可延迟、可配置的过程。

当你写下 curriedAdd(1)(2) 时，你不仅是在做两次函数调用，更是在构建一个由作用域链守护的参数管道——每一次括号，都是对闭包包中状态的一次信任交付。而这，正是函数式思维的魅力所在。

avatar
文章
阅读
粉丝