函数柯里化

一、柯里化：把接收多个参数的函数变换成接收一个单一参数的函数（单一参数为多个参数中的第一个）

函数柯里化思想：一个JS预处理的思想，降低通用性，提高适用性。

特点：

参数复用	需要输入多个参数，最终只需输入一个，其余通过arguments来获取
提前返回	避免重复去判断某一条件是否符合，不符合则return 不再继续执行下面的操作
延迟执行	避免重复的去执行程序，等真正需要结果的时候再执行

function fn(){
    console.log(this)
}

这里的This是window，要改变this指向，用Bind

function bind(callback,context){
   context=context||window;
   //把callback方法中的this预先处理为context
   return function(){
       callback.call(context)
    }
   
}

核心原理：利用函数执行可以形成一个不销毁的私有作用域，把预先处理的内容都存在这个不销毁的作用域里面，并且返回一个小函数，以后要执行的就是这个小函数。

fn.bind(obj,100,200)

思考：如何给Bind传值

具体参数不知道，不能定死数据的个数，使用argments

var outerArg=Array.prototype.slice.call(arguments,2);
//利用Array的slice方法取到外部传入参数的第二个及以后多个参数
callback.call(context,outerArg)

二、参数复用

var currying=function(fn){
  var args=[];
  return function cb(){
    if(arguments.length===0){
      return fn.apply(this,args)
    }
    console.log(arguments)
   Array.prototype.push.apply(args,[].slice.call(arguments))
    //args.push([].slice.call(arguments))
    console.log(args)
    return cb
  }
}
 function add(a,b,c){
  console.log(a+b+c);
 }
  var s=currying(add);
  s(1)(2)(3)();

 运行结果为：

如果使用args.push([].slice.call(arguments))

对比可以知道args是一个类数组对象，使用args.push 每次压入一个arguments。并不会对传入的一系列数字行拆分使用。

而用Array.push(),则把每次传入的数存在数组里面。

[].slice.call(arguments)这是一个数组，里面只有一个参数，本例来说是[1],[2],[3]

而使用apply(args,[].slice.call(arguments))，apply将一个数组默认的转换为一个参数列表，那么参数（1,2,3）陆续传入数组。

三、提前返回

var addEvent = function(){
  if (window.addEventListener) { //判断是否支持
    return function(el, sType, fn, capture) {
      el.addEventListener(sType, function(e) {
        fn.call(el, e);
      }, (capture));
    };
  } else if (window.attachEvent) {
    return function(el, sType, fn, capture) {
      el.attachEvent("on" + sType, function(e) {
        fn.call(el, e);
      });
    };
  }
};
var elBind=addEvent();
var span=document.getElementById("s");
var div=document.getElementById("d");
elBind(span, 'click', function () {console.log("1")}, false)
elBind(div, 'click', function () {console.log("1")}, false)

 如上面代码对于监听事件的判断则只会走一次，如果是传统函数则会多次执行。则真是提前返回的好处。

总结：经测试，上述代码var elBind=addEvent();就会先判断一次浏览器的环境，然后返回一个小函数。

之后elBind(span, 'click', function () {console.log("1")}, false)
elBind(div, 'click', function () {console.log("1")}, false)

均只执行小函数，不会再多次判断浏览器环境。

四、延迟执行

举例如下：

var curryScore=function(fn){
  var allScore=[];//用来存取每次输入的单个值
  // 这些用来预处理
  return function(){
    if(arguments.length===0){
      // fn(allScore);
    fn.apply(null,allScore)
    }else{   //往集合里添加分数
      allScore=allScore.concat([].slice.call(arguments));
      //allScore.push([].slice.call(arguments))
      //allScore.push(Array.prototype.slice.call(arguments))
    }
  }
};
var result=0;
var addScore=curryScore(function(){
  console.log(this)
  console.log(arguments);
  for(var i=0;i<arguments.length;i++){
    result+=arguments[i];
  }
})

addScore(3);
addScore(3);
console.log(result)
addScore(3);
addScore();
console.log(result)

  输出结果：

这就是第三个特点，延迟执行，再没有输入参数时，不计算总结果。等需要计算的时候，再计算。

1、如果使用  fn(allScore);输出为

this为window，arguments是一个对象，第一项为数组
    本例使用 fn.apply(null,allScore)，输出为：

this也为window，但是arguments是一个数组了，

apply（）方法接受的是一个包含多个参数的数组（或类数组对象）。用apply方法来实现用数组的参数来传递。而apply方法第一个参数，是要替代的对象。没有要替代的，用null。用数组的参数来传递，就可以在计算求和的时候，直接使用arguments[i]。

apply的一个巧妙的用处,可以将一个数组默认的转换为一个参数列表

即[param1,param2,param3] 转换为 param1,param2,param3

2、补充：

a)     Math.max 可以实现得到数组中最大的一项

因为Math.max 参数里面不支持Math.max([param1,param2]) 也就是数组

但是它支持Math.max(param1,param2,param3…),所以可以根据刚才apply的那个特点来解决

var max=Math.max.apply(null,array),这样轻易的可以得到一个数组中最大的一项(apply会将一个数组装换为一个参数接一个参数的传递给方法)

         这块在调用的时候第一个参数给了一个null,这个是因为没有对象去调用这个方法,我只需要用这个方法帮我运算,得到返回的结果就行,.所以直接传递了一个null过去

b)        Math.min  可以实现得到数组中最小的一项

同样和 max是一个思想 var min=Math.min.apply(null,array);

c)        Array.prototype.push 可以实现两个数组合并

同样push方法没有提供push一个数组,但是它提供了push(param1,param,…paramN) 所以同样也可以通过apply来装换一下这个数组,即:

var arr1=new Array("1","2","3");  
  
var arr2=new Array("4","5","6");  
  
Array.prototype.push.apply(arr1,arr2); 

也可以这样理解,arr1调用了push方法,参数是通过apply将数组装换为参数列表的集合.