什么是柯里化（currying）
柯里化是一个将多元函数转化为低元函数的操作过程，可以看做是多元函数的部分求值过程，一个柯里化的函数可能会接受一些参数，但在接受这些参数后，并不会立即运算求值，而是返回另外一个函数，传入的参数在函数中通过闭包的方式保存起来，等到需要求值的时候，在一次性运算求值。
举例
现在假设你是一个小超市的收银员，在每天工作结束后，你都要记录今天的收银账目，并且在每个月的月底跟老板汇报，这个月的收银总数。
你可以采用如下方式：
- 每天记录当日收银，并且每天都计算一次收银总数
- 每天记录当日收银，在月底的时候一起算出总数
方式一
var sum = 0;
var count = function(daycount){
sum += daycount
}
count(100) //第1天
count(200) //第2天
count(300)
// ...
count(200) // 第30天
console.log(sum )
方式二
function count (){
var args = [];
return function(){
//如果没有参数，则开始计算
if(arguments.length === 0){
var sum = 0;
for(var i=0;i<args.length;i++){
sum += args[i]
}
return sum
}else{
//如果有参数，暂存到args中
[].push.apply(args,arguments);
}
}
};
count(100); // args --- [100]
count(200); // args --- [100,200]
count(300); // args --- [100,200,300]
console.log(count()); // sum --- 600
方法二的代码就是一个currying函数，当传入参数时，并没有执行，只是进行暂存的操作，只有通过count() 方式执行时，才会真正运算。
通用的柯里化函数
var currying = function (fn) {
var args = [];
return function () {
if (arguments.length === 0) {
return fn.apply(this, args);
} else {
[].push.apply(args, arguments);
//callee属性指代当前正在执行的函数
return arguments.callee;
}
}
};
var count= (function () {
var sum= 0;
return function () {
for (var i = 0; i < arguments.length; i++) {
sum+= arguments[i];
}
return sum;
}
})();
var count= currying(count); // 转化成 currying 函数
count(100);
count(200);
count(300);
console.log(count()); // 求值并输出：600
上面就是一个通用的currying函数，现在这个currying函数只能接收一个参数 fn ，但有时我们可能不仅仅只传一个需要柯里化的函数，还要传一些额外的参数，这就需要对上面的函数进行改写
可传参的柯里化函数
var currying = function (fn) {
var args = [];
/*将除了第一个参数fn之外的参数，存储到args中
arguments本身是没有slice方法的，因此想取到arguments中除了第一项以外的参数
就要通过[].slice.call(arguments,1) 相当于把数组slice的方法，搬到arguments上
*/
args = args.concat([].slice.call(arguments,1));
return function () {
if (arguments.length === 0) {
return fn.apply(this, args);
} else {
[].push.apply(args, arguments);
//callee属性指代当前正在执行的函数
return arguments.callee;
}
}
};
什么是反柯里化(uncurrying)
顾名思义，反柯里化的意义和柯里化相反，柯里化是一个逐步传参，逐步缩小函数的使用范围的过程
而反柯里化作用在于扩大函数的使用性，将本来作为特性对象所拥有的功能函数变成可以被任意对象所使用
比如：
obj.func(arg1,arg2)
变成
func(obj,arg1,arg2)
就是一个反柯里化的过程
简单实现
Function.prototype.uncurrying = function() {
var thiz= this;
return function() {
return Function.prototype.call.apply(thiz,arguments);
}
};
function sayHi () {
return "Hello " + this.value +" "+[].slice.call(arguments);
}
var sayHiuncurrying=sayHi.uncurrying();
console.log(sayHiuncurrying({value:'world'},"hahaha"));
因为uncurrying是定义在Function的prototype上的方法，因此所有的函数都可以使用改方法。
在调用的时候，uncurrying中的this指向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)
通用的反柯里化函数
var uncurrying= function (fn) {
return function () {
var args=[].slice.call(arguments,1);
return fn.apply(arguments[0],args);
}
};