JavaScript反柯里化（Uncurrying）详解与通用实现

反柯里化概念与原理

反柯里化

与常规柯里化相反，反柯里化的核心目的在于扩展函数的适用范围，使得原本仅属于特定对象的方法能够被任意对象调用。

具体而言，反柯里化旨在转换给定的函数签名，

obj.func(arg1, arg2)

将其转化为一种新的函数形式，其签名结构如下：

func(obj, arg1, arg2)

上述即为反柯里化的形式化定义。

以下是一个简单的实现示例：

Function.prototype.uncurrying = function() {
  var that = this;
  return function() {
    return Function.prototype.call.apply(that, arguments);
  }
};

function sayHi () {
  return "Hello " + this.value +" "+[].slice.call(arguments);
}
var sayHiuncurrying=sayHi.uncurrying();
console.log(sayHiuncurrying({value:'world'},"hahaha"));

代码解析：

• uncurrying 是定义在 Function 原型上的方法，因此所有函数均可使用。调用时如 sayHiuncurrying = sayHi.uncurrying()，此时 uncurrying 内部的 this 指向 sayHi 函数。在 JavaScript 中，函数也是对象，原型方法中的 this 通常指向调用者，此处调用者为另一个函数。
• 通过 call.apply(that, arguments)，将 that 设为 call 的上下文，并将 arguments 传递给 call。在前例中，that 实际指向 sayHi，因此调用 sayHiuncurrying(arg1, arg2, ...) 等效于 sayHi.call(arg1, arg2, ...)。
• 在 sayHi.call(arg1, arg2, ...) 中，call 将 arg1 作为 sayHi 的执行上下文，并将剩余参数 arg2 等传递给 sayHi，最终效果等同于 arg1.sayHi(arg2, ...)。
• 由此可见，sayHiuncurrying(obj, args) 等价于 obj.sayHi(args)。

反向思考，反柯里化将原本 sayHi(args) 的形式转换为 sayHiuncurrying(obj, args)，从而泛化了 sayHi 的使用范围。更抽象地讲，反柯里化使得原本 x.y(z) 的调用方式，可以转换为 y(x', z) 的形式。若 x' 可以是 x 或其他对象，则函数的适用性得到了显著扩大。

通用反柯里化函数实现

通用反柯里化函数

前例将 uncurrying 写入原型并非最佳实践，我们可以将其封装为独立的函数：

var uncurrying= function (fn) {
  return function () {
    var args=[].slice.call(arguments,1);
    return fn.apply(arguments[0],args);    
  }  
};

该函数逻辑清晰直观。

使用时，调用 uncurrying 并传入现有函数 fn。反柯里化函数返回一个新函数，该新函数的第一个实参将绑定为 fn 中 this 的上下文，其余参数则传递给 fn 作为其参数。

因此，对反柯里化更通俗的解释是“函数借用”，即让函数能够处理其他对象，通过借用机制泛化并扩大函数的使用范围。

反柯里化更常见的应用场景是借用 JavaScript 内置的其他方法，从而避免重复实现。

文字描述可能较为抽象，请结合以下代码理解：

var test="a,b,c";
console.log(test.split(","));

var split=uncurrying(String.prototype.split);  //[ 'a', 'b', 'c' ]
console.log(split(test,','));          //[ 'a', 'b', 'c' ]

例如，split = uncurrying(String.prototype.split)。将具体的 fn（即 String.prototype.split）传入 uncurrying，split 函数便获得了 String.prototype.split 的功能。调用 split(test, ',') 时，传入的第一个参数作为 split 执行的上下文，剩余参数则传递给原 String.prototype.split 函数。

再看一个示例：

var $ = {};
console.log($.push);             // undefined
var pushUncurrying = uncurrying(Array.prototype.push);
$.push = function (obj) {
  pushUncurrying(this,obj);
};
$.push('first');
console.log($.length);            // 1
console.log($[0]);              // first
console.log($.hasOwnProperty('length'));   // true

此例模仿了类似 jQuery 库中借用 Array 的 push 方法。我们知道普通对象没有 push 方法，console.log(obj.push) 返回 undefined。通过借用 Array 的 push，由原生数组方法（JS引擎）来维护伪数组对象的 length 属性和数组成员。

同理，我们还可以继续扩展：

var indexof=uncurrying(Array.prototype.indexOf);
$.indexOf = function (obj) {
  return indexof(this,obj);
};
$.push("second");
console.log($.indexOf('first'));       // 0
console.log($.indexOf('second'));       // 1
console.log($.indexOf('third'));       // -1

例如在实现自己的类库时，若某些方法与原生方法类似，可通过 uncurrying 借用原生方法。

我们还可以对 Function.prototype.call/apply 方法进行 uncurrying，例如：

var call= uncurrying(Function.prototype.call);
var fn= function (str) {
  console.log(this.value+str);
};
var obj={value:"Foo "};
call(fn, obj,"Bar!");            // Foo Bar!

这使得我们可以灵活地将函数作为普通“数据”使用，带有函数式编程的风格，此类用法在各类类库中十分常见。

进阶实现与应用场景

通用 uncurrying 函数的进阶版本

上述 uncurrying 函数符合常规思维且易于理解，接下来展示几个其他进阶版本：

首先，若追求代码简洁，uncurrying 可写成如下形式：

var uncurrying= function (fn) {
  return function () {
    var context=[].shift.call(arguments);
    return fn.apply(context,arguments);
  }
};

若需进一步提升代码的简洁度，还可以采用以下写法：

var uncurrying= function (fn) {
  return function () {    
    return Function.prototype.call.apply(fn,arguments);
  }
};

以上即为本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持本站。