即把如下给定的函数签名，
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的prototype上的方法，因此对所有的函数都可以使用此方法。调用时候：sayhiuncurrying=sayhi.uncurrying()，所以uncurrying中的 this 指向的是 sayhi 函数; （一般原型方法中的 this 不是指向原型对象prototype，而是指向调用对象，在这里调用对象是另一个函数，在javascript中函数也是对象）
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的使用范围泛化了。 更抽象地表达， uncurryinging反柯里化，使得原来 x.y(z) 调用，可以转成 y(x',z) 形式的调用 。 假设x' 为x或者其他对象，这就扩大了函数的使用范围。
通用反柯里化函数上面例子中把uncurrying写进了prototype，这不太好，我们其实可以把 uncurrying 单独封装成一个函数;
var uncurrying= function (fn) { return function () { var args=[].slice.call(arguments,1); return fn.apply(arguments[0],args); } };
上面这个函数很清晰直接。
使用时 调用 uncurrying 并传入一个现有函数 fn， 反柯里化函数会返回一个新函数，该新函数接受的第一个实参将绑定为 fn 中 this的上下文，其他参数将传递给 fn 作为参数。
所以，对反柯里化更通俗的解释可以是 函数的借用，是函数能够接受处理其他对象，通过借用泛化、扩大了函数的使用范围。
所以 uncurrying更常见的用法是对 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) 给 uncurrying 传入一个具体的fn，即string.prototype.split ，split 函数就具有了 string.prototype.split 的功能，函数调用 split(test,',') 时，传入的第一个参数为 split 执行的上下文，剩下的参数相当于传给原 string.prototype.split 函数。
再看一个例子:
var $ = {}; console.log($.push); // undefinedvar pushuncurrying = uncurrying(array.prototype.push); $.push = function (obj) { pushuncurrying(this,obj); }; $.push('first'); console.log($.length); // 1console.log($[0]); // firstconsole.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')); // 0console.log($.indexof('second')); // 1console.log($.indexof('third')); // -1
例如我们在实现自己的类库时，有些方法如果有些方法和原生的类似，那么可以通过 uncurrying 借用原生方法。
我们还可以把 function.prototype.call/apply 方法 uncurring，例如：
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 函数是比较符合思维习惯容易理解的版本，接下来一路进击，看几个其他版本：
首先，如果b格高一点，uncurrying 也可能写成这样：
var uncurrying= function (fn) { return function () { var context=[].shift.call(arguments); return fn.apply(context,arguments); } };
当然如果还需要再提升b格，那么还可以是这样：
var uncurrying= function (fn) { return function () { return function.prototype.call.apply(fn,arguments); } };
以上就是js中的反柯里化的详细内容。