javascript学习——高阶函数的几种常见应用

1、curring：部分求值。一个curring的函数会接收一些参数，接受了参数之后的该函数并不会立即求值，而是继续返回一个函数，并把之前传入的参数保存在闭包里面。等到函数真正需要求值的时候，之前传入的所有参数会一次性的用于求值。

var curring = function(fn){
  var args = [];

  return function(){
     if(arguments.length  === 0){
         fn.apply(this,args); 
   }else{
         [].push.apply(args,arguments);
         return arguments.callee;
    }
  }
}

2、uncurring: 它解决的问题是让对象去借用一个不属于自己的方法。

Function.prototype.uncurring = function(){
   var self = this;
   return function(){
     var obj = Array.prototype.shift(arguments);
     return self.apply(obj,arguments);
  }
}

3、函数节流：当函数触发的频率过高，而函数的执行本身比较开销比较大。那么可以把函数的执行放在一个定时器里面，定时器结束之后再统一执行。

var throttle = function(fn,interval){
   var _self = fn,timer,firstTime = true;

   return function(){
     var args = arguments;
     var _me = this;
     if(firstTime){
        _self.apply(_me,args);
       return false;
     }

     if(timer){
       return false;
      }

     timer = setTimeout(function(){
         clearTimeout(timer);
         timer = null;
         _self.apply(_me,args);
      },interval || 500);
   };  
};

4、分时函数：如果一个函数是用户主动发起的，但是这些函数严重影响页面的性能。比如说一次性创建很多节点，那么可以把这些函数分批次执行。

var timeChunk =function(ary,fn,count){
    var obj,t;
    var len = ary.length;

    start = function(){
       for(var i=0; i< Math.min(count||1,len); i++){
           var obj = ary.shift();
           fn(obj);
       }
    };

    return function(){
         t = setInterval(function(
            if(ary.length == 0){
                return clearInteval(t);
            }

            start();
        ),200);
     };
  
};

5、加载惰性函数：在进入第一个分支的时候，函数内部重写这个函数，重写之后的函数就是我们期望得到的函数.常见的就是嗅探函数

var addEvent = function(elem,type,handle){
    if(window.addEventListener){
      addEvent = function(elem,type,handle){
         elem.addEventListener(type,handle);
     }
   }else if(window.attachEvent){
         addEvent = function(elem,type,handle){
           elem.attachEvent('on' + type,handle);
       }
      }
     addEvent(elem,type,handle);
}