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);

// 首先定義一個變量接收函數(shù)
var overtime = (function() {
//定義一個數(shù)組用來接收參數(shù)
 var args = [];
//這里運用閉包，調(diào)用外部函數(shù)返回一個內(nèi)部函數(shù)
 return function() {
　　//arguments是瀏覽器內(nèi)置對象，專門用來接收參數(shù)
　　//如果參數(shù)的長度為0即沒有參數(shù)的時候
  if(arguments.length === 0) {
　　　　//定義變量用來累加
   var time = 0;
　　　　//循環(huán)累加，用i和args的長度進行比較
   for (var i = 0, l = args.length; i < l; i++) {
　　　　//進行累加操作  等價于time=time+args[i]
    time += args[i];
   }
　　　　// 返回累加的結(jié)果
   return time;
　　　　//如果arguments對象參數(shù)長度不為零，即有參數(shù)的時候
  }else {
　　　　//定義的空數(shù)組添加arguments參數(shù)作為數(shù)組項,第一個參數(shù)古args作為改變this指向，第二個參數(shù)arguments把剩余參數(shù)作為數(shù)組形式添加至空數(shù)組中
   [].push.apply(args, arguments);
  }
 }
})();

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

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

//定義方法currying，先傳入一個參數(shù)
var currying=function(fn){
　　//定義空數(shù)組裝arguments對象的剩余參數(shù)
 var args=[];
　　//利用閉包返回一個函數(shù)處理剩余參數(shù)
 return function (){
　　　　//如果arguments的參數(shù)長度為0，即沒有剩余參數(shù)
  if(arguments.length===0){
　　　　//執(zhí)行上面方法
　　　　//這里的this指向下面的s，類似于s()，代表參數(shù)長度為0的時候直接調(diào)用函數(shù)
   return fn.apply(this,args)
  }
  console.log(arguments)
　　//如果arguments的參數(shù)長度不為0，即還有剩余參數(shù)
　　//在數(shù)組的原型對象上添加數(shù)組，apply用來更改this的指向為args
　　//將[].slice.call(arguments)的數(shù)組添加到原型數(shù)組上
　　//這里的[].slice.call(arguments)===Array.prototype.slice.call(arguments)實質(zhì)上就是將arguments對象轉(zhuǎn)成數(shù)組并具有slice功能

  Array.prototype.push.apply(args,[].slice.call(arguments))
  //args.push([].slice.call(arguments))
  console.log(args)
　　//這里返回的arguments.callee是返回的閉包函數(shù)，callee是arguments對象里面的一個屬性，用于返回正被執(zhí)行的function對象
  return arguments.callee
 }
}
　　//這里調(diào)用currying方法并傳入add函數(shù)，結(jié)果會返回閉包內(nèi)部函數(shù)
 var s=currying(add);
　　//調(diào)用閉包內(nèi)部函數(shù)，當有參數(shù)的時候會將參數(shù)逐步添加到args數(shù)組中，待沒有參數(shù)傳入的時候直接調(diào)用
　　//調(diào)用的時候支持鏈式操作
 s(1)(2)(3)();
//也可以一次性傳入多個參數(shù)
  s(1,2,3);
 console.log(s());

//函數(shù)原型對象上添加uncurring方法
Function.prototype.uncurring = function() {
//改變this的指向  
//這里的this指向是Array.prototype.push
 var self = this;
  //這里的閉包用來返回內(nèi)部函數(shù)的執(zhí)行
 return function() {
  //創(chuàng)建一個變量，在數(shù)組的原型對象上添加shift上面刪除第一個參數(shù)
  //改變數(shù)組this的指向為arguments
  var obj = Array.prototype.shift.call(arguments);
  //最后返回執(zhí)行并給方法改變指向為obj也就是arguments
  // 并傳入arguments作為參數(shù)
  return self.apply(obj, arguments);
 };
};

//數(shù)組原型對象上添加uncurrying方法
var push = Array.prototype.push.uncurring();

//測試一下
//匿名函數(shù)自執(zhí)行
(function() {
  //這里的push就是一個函數(shù)方法了
  //相當于傳入?yún)?shù)arguments和4兩個參數(shù)，但是在上面shift方法中刪除第一個參數(shù)，這里的arguments參數(shù)被截取了，所以最后實際上只傳入了4
 push(arguments, 4);
 console.log(arguments); //[1, 2, 3, 4]
//匿名函數(shù)自調(diào)用并帶入?yún)?shù)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;
  //閉包返回一個內(nèi)部函數(shù)
  return function() {
  // 這里可以拆開理解
  //首先執(zhí)行apply return 
  //Function.prototype.call(Array.prototype.push[obj,2])
  //然后Array.prototype.push.call(obj,2)
  //call改變指向 obj.push(2)
  //所以最后結(jié)果就是 {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);