javascript实现函数柯里化与反柯里化过程解析

var overtime=0;
function time(x){
  return overtime+=x;
}

time(1); //1
time(2); //3
time(3); //6

function time(x){
 return function(y){
    return x+y;
  }   
}

var times=time(0);
times(3);

// 首先定义一个变量接收函数
var overtime = (function() {
//定义一个数组用来接收参数
 var args = [];
//这里运用闭包，调用外部函数返回一个内部函数
 return function() {
　　//arguments是浏览器内置对象，专门用来接收参数
　　//如果参数的长度为0即没有参数的时候
  if(arguments.length === 0) {
　　　　//定义变量用来累加
   var time = 0;
　　　　//循环累加，用i和args的长度进行比较
   for (var i = 0, l = args.length; i < l; i++) {
　　　　//进行累加操作  等价于time=time+args[i]
    time += args[i];
   }
　　　　// 返回累加的结果
   return time;
　　　　//如果arguments对象参数长度不为零，即有参数的时候
  }else {
　　　　//定义的空数组添加arguments参数作为数组项,第一个参数古args作为改变this指向，第二个参数arguments把剩余参数作为数组形式添加至空数组中
   [].push.apply(args, arguments);
  }
 }
})();

overtime(3.5);  // 第一天
overtime(4.5);  // 第二天
overtime(2.1);  // 第三天
//...

console.log( overtime() );  // 10.1

//定义方法currying，先传入一个参数
var currying=function(fn){
　　//定义空数组装arguments对象的剩余参数
 var args=[];
　　//利用闭包返回一个函数处理剩余参数
 return function (){
　　　　//如果arguments的参数长度为0，即没有剩余参数
  if(arguments.length===0){
　　　　//执行上面方法
　　　　//这里的this指向下面的s，类似于s()，代表参数长度为0的时候直接调用函数
   return fn.apply(this,args)
  }
  console.log(arguments)
　　//如果arguments的参数长度不为0，即还有剩余参数
　　//在数组的原型对象上添加数组，apply用来更改this的指向为args
　　//将[].slice.call(arguments)的数组添加到原型数组上
　　//这里的[].slice.call(arguments)===Array.prototype.slice.call(arguments)实质上就是将arguments对象转成数组并具有slice功能

  Array.prototype.push.apply(args,[].slice.call(arguments))
  //args.push([].slice.call(arguments))
  console.log(args)
　　//这里返回的arguments.callee是返回的闭包函数，callee是arguments对象里面的一个属性，用于返回正被执行的function对象
  return arguments.callee
 }
}
　　//这里调用currying方法并传入add函数，结果会返回闭包内部函数
 var s=currying(add);
　　//调用闭包内部函数，当有参数的时候会将参数逐步添加到args数组中，待没有参数传入的时候直接调用
　　//调用的时候支持链式操作
 s(1)(2)(3)();
//也可以一次性传入多个参数
  s(1,2,3);
 console.log(s());

//函数原型对象上添加uncurring方法
Function.prototype.uncurring = function() {
//改变this的指向  
//这里的this指向是Array.prototype.push
 var self = this;
  //这里的闭包用来返回内部函数的执行
 return function() {
  //创建一个变量，在数组的原型对象上添加shift上面删除第一个参数
  //改变数组this的指向为arguments
  var obj = Array.prototype.shift.call(arguments);
  //最后返回执行并给方法改变指向为obj也就是arguments
  // 并传入arguments作为参数
  return self.apply(obj, arguments);
 };
};

//数组原型对象上添加uncurrying方法
var push = Array.prototype.push.uncurring();

//测试一下
//匿名函数自执行
(function() {
  //这里的push就是一个函数方法了
  //相当于传入参数arguments和4两个参数，但是在上面shift方法中删除第一个参数，这里的arguments参数被截取了，所以最后实际上只传入了4
 push(arguments, 4);
 console.log(arguments); //[1, 2, 3, 4]
//匿名函数自调用并带入参数1，2，3
})(1, 2, 3)

//定义一个对象
var obj = {
  "length":1,
  "0":1
}
//在Function原型对象定义方法uncurrying
Function.prototype.uncurrying = function() {
  //this指向Array.prototype.push
  var self = this;
  //闭包返回一个内部函数
  return function() {
  // 这里可以拆开理解
  //首先执行apply return 
  //Function.prototype.call(Array.prototype.push[obj,2])
  //然后Array.prototype.push.call(obj,2)
  //call改变指向 obj.push(2)
  //所以最后结果就是 {0: 1, 1: 2, length: 2}
    return Function.prototype.call.apply(self, arguments);
}
}

//在
var push = Array.prototype.push.uncurrying()

push(obj, 2) 
console.log(obj);
//{0: 1, 1: 2, length: 2}

Function.prototype.unCurrying = function () {
  var self = this;
  return function () {
　　　　//[].slice.call(arguments,1)===Array.prototype.push.slice.call(arguments,1)===arguments.slice(1)
return self.apply(arguments[0], [].slice.call(arguments, 1));
  };
};
var push = Array.prototype.push.uncurrying()
console.log(push);
push(obj,2) //{0: 1, 1: 2, length: 2}
console.log(obj);