深入剖析JavaScript中的函数柯里化(Currying)

结果或目标：什么是柯里化

柯里化来源于数学家 Haskell Curry 的名字，同样编程语言 Haskell 也是以他命名的。在 JavaScript 中，柯里化通常也被称为“部分求值”。它的核心含义是给函数分步传递参数，每次传递参数后部分应用参数，并返回一个更具体的新函数来接受剩下的参数。

这一过程可以嵌套多层，直到收集完所有参数并最终返回结果。简而言之，柯里化的过程就是逐步传参、逐步缩小函数适用范围、逐步求解的过程。

准备条件：基础概念支撑

要深刻理解并实现柯里化，需要掌握 JavaScript 的几个核心特性：

• 高阶函数：即操作函数的函数，它接收一个或多个函数作为参数，并返回一个新函数。
• 函数返回值：函数可以作为另一个函数的返回值被返回，这是形成“函数链”的基础。
• 闭包：内部函数引用外部函数的变量，即使外部函数执行完毕，变量依然保存在内存中，用于累积参数。

真实操作顺序：柯里化的实现步骤

第1步：理解单参逐层调用的基础形态

首先看一个简单的字符串拼接例子。原生函数通常一次性接收所有参数，而柯里化版本则拆分为每一步接收一个参数。

// 普通函数
var concat3Words = function (a, b, c) {
  return a + b + c;
};

// 柯里化函数
var concat3WordsCurrying = function(a) {
  return function (b) {
    return function (c) {
      return a + b + c;
    };
  };
};

console.log(concat3Words("foo ","bar ","baza")); // foo bar baza
// 柯里化调用方式
console.log(concat3WordsCurrying("foo ")("bar ")("baza")); // foo bar baza

如代码所示，concat3WordsCurrying("foo") 返回的是一个函数，该函数继续接收 b，再返回新函数接收 c，最终得出结果。这正是利用了闭包的特性保存每一层的参数。

第2步：构建支持任意数量参数的累加器

当我们需要处理动态数量的参数（如多个数字相加），且支持链式调用并在最后不传参时输出结果时，代码结构需要进行调整。

var adder = function () {
  var _args = []; // 用于保存所有传入的参数
  return function () {
    if (arguments.length === 0) {
      // 如果没有传入参数，说明调用结束，执行最终计算
      return _args.reduce(function (a, b) {
        return a + b;
      });
    }
    // 否则，将新传入的参数追加到数组中
    [].push.apply(_args, [].slice.call(arguments));
    // 返回函数自身，支持链式调用
    return arguments.callee;
  };
};

var sum = adder();

sum(100, 200)(300); // 灵活传参，支持单次传多个
sum(400);
console.log(sum()); // 1000 （最后一次调用不加参数触发计算）

上述 adder 就是一个典型的柯里化函数。它通过 _args 数组暂存参数，只有当检测到未传参时，才通过 reduce 进行累加。这种机制使得参数传入非常灵活。

第3步：封装通用的高阶柯里化工具函数

上面的累加器仅适用于加法。为了使柯里化具备通用性，我们可以把“最终的计算逻辑”作为一个函数 fn 传入构造器中。这样既能分离关注点，又能复用柯里化的逻辑框架。

// 通用柯里化工厂函数
var currying = function (fn) {
  var _args = [];
  return function () {
    if (arguments.length === 0) {
      // 无参时，使用已收集的参数执行真正的业务函数 fn
      return fn.apply(this, _args);
    }
    // 有参时，将参数加入缓存池
    Array.prototype.push.apply(_args, [].slice.call(arguments));
    return arguments.callee; // 返回自身，继续接受参数
  };
};

// 定义具体的业务逻辑（例如累加）
var multi = function () {
  var total = 0;
  for (var i = 0, c; c = arguments[i++];) {
    total += c;
  }
  return total;
};

// 实例化
var sum = currying(multi);

sum(100, 200)(300);
sum(400);
console.log(sum());   // 1000

这种模式下，sum = currying(multi) 职责清晰：currying 负责管理参数收集和延迟执行，multi 负责具体的数值计算。

完成判断与应用场景

验证柯里化是否成功

判断一个函数是否实现了柯里化，主要观察以下两点： 1. 函数可以通过 f(x)(y)(z) 的形式连续调用。 2. 存在一个特定的时机（通常是空参调用）触发最终的逻辑执行。

实际工程中的作用

• 参数复用：在多次调用同一类函数且大部分参数相同时（如特定浏览器的API适配），可通过柯里化固化固定参数，简化后续调用。
• 延迟计算：正如上述累加器所示，可以将复杂运算推迟到数据完全准备好之后再执行。
• 动态创建函数（偏应用）：这是最经典的应用场景之一——浏览器事件监听器的兼容封装。

原文有依据的排错与进阶：Event绑定优化案例

在未优化的事件添加函数中，每次调用都要执行 if...else... 来判断浏览器兼容性：

// 低效写法：每次都重复判断
var addEvent = function(el, type, fn, capture) {
  if (window.addEventListener) {
    el.addEventListener(type, function(e) { fn.call(el, e); }, capture);
  } else if (window.attachEvent) {
    el.attachEvent("on" + type, function(e) { fn.call(el, e); });
  }
};

利用柯里化思想，可以在第一次调用时完成判断，并动态生成一个新的函数供后续使用。这就是“动态创建函数”的应用：

// 高效的柯里化写法
var addEvent = (function(){
  if (window.addEventListener) {
    // 第一次判断后，直接返回标准方法的具体实现
    return function(el, sType, fn, capture) {
      el.addEventListener(sType, function(e) { fn.call(el, e); }, (capture));
    };
  } else if (window.attachEvent) {
    // 如果是不支持标准DOM2事件的浏览器，返回特殊逻辑的实现
    return function(el, sType, fn, capture) {
      el.attachEvent("on" + sType, function(e) { fn.call(el, e); });
    };
  }
})();

注意这里的立即执行函数表达式（IIFE），它在模块加载时执行一次分支判断，然后赋值给 addEvent 为对应的具体函数。这本质上是柯里化的一种宏观体现：基于环境的不同，生成特定的处理逻辑。

简要总结：Function.prototype.bind

JavaScript 内置的 Function.prototype.bind 方法是柯里化的另一典型代表。它与 call/apply 的区别在于：bind 不立即执行函数，而是绑定上下文并返回一个新函数。

var foo = {x: 888};
var bar = function () {
  console.log(this.x);
}.bind(foo); // 返回新函数，延迟执行
bar();           // 输出 888

如果我们尝试模拟 bind 的内部原理，代码逻辑如下：

Function.prototype.testBind = function (scope) {
  var fn = this;          // 捕获原始函数
  return function () {
    // 绑定作用域后，返回一个包装函数，真正执行放在这里
    return fn.apply(scope);
  };
};

var testBindBar = bar.testBind(foo); 
console.log(testBindBar);       // Function (可见 bind 之后返回的是新函数)
testBindBar();            // 888

综上所述，无论是手写工具库、编写测试用例还是优化底层代码，柯里化都能帮助我们写出更具表现力、更高效且易于复用的 JavaScript 代码。以上就是深入剖析JavaScript函数柯里化的详细内容，更多关于JavaScript高级特性的资料请关注本站其它相关文章！