柯里化 bind 惰性模式 参数累计 参与者模式

起源

函数式语言的currying特性来自于lambda calculus，lambda calculus只支持单参函数，但它可以返回一个函数来接受第二个参数。

function f(a){
    return function(b){ a + b} // 返回新函数来接受第二个参数
}
f(1)(1) // 2 

柯里化的意义

代码技巧的目的：
1.提高性能
2.提高可维护性：模块化，减小耦合增强可维护性
柯里化属于第二种

柯里化常用应用：绑定参数、提前运行、延迟执行

场景1：绑定参数

原理：通过闭包绑定参数
其他说法：参数复用，参数分割、局部套用、局部求值

// 创建 柯里化函数
function curry(fn){//第一个参数为函数，其他为fn的参数
    //截取 第二个以后的参数  ES6 可以不使用此方法了
    var args = [].slice.call(arguments, 1); // arguments 表示slice调用的对象 1为slice参数
    return function(){
        var addArgs = [].slice.call(arguments);// 新参数转数组
        var allArgs = args.concat(addArgs); // 合并curry的固定参数和 新的参数
        return fn.apply(null, allArgs); // 调用 
        //this = null 默认绑定；this指向window 
    }
}
// 简单应用 3个参数的api 调用
api1('myapp', 'xiaoming', '小明');
api1('myapp', 'xiaohong', '小红');
api1('myapp', 'xiaogang', '小刚');
// 通过柯里化函数将共同参数抽离出来 
var myApi2 = curry(api1, "myapp");
myApi2('xiaoming', '小明');
myApi2('xiaohong', '小红');
myApi2('xiaogang', '小刚');
// 使用此方法也可以实现
// 但需要对多个函数进行参数绑定就需要编写多个重复的语句
// 而且柯里化函数有更好的扩展性
let myApi2 = function(token, uid){
    api2( "myApp", token, uid);
}

重构bind：进一步理解

bind：返回新函数，绑定this指向的函数
apply：执行指定this的函数
实现：通过闭包缓存 函数和context。返回apply调用fn指向context的新函数；

function bind(fn, context){ // 缓存 fn 和 context参数
    args  = [].slice.call(arguments, 3); // 缓存 绑定的参数
    return function(){
        var addArgs = [].slice.call(arguments); // 转数组 
        var allArgs = addArgs.concat(args) // 合并绑定的参数和新传入的参数
        return fn.apply(context, allArgs); // apply调用
    }
}

场景2：提前运行——惰性模式

惰性模式：通过重新定义函数，免去重复的判断，一般用于兼容浏览器
模式1：立即执行执行——加载时候重定义(消耗加载性能)
模式2：惰性执行——执行第一次时重定义(消耗第一次执行性能)
绑定事件例子：

// 自执行
var addEvent = (function(){
    if(window.addEventListener){
        return function(dom, type, fn){
            dom.addEventListener(type, fn, false);
        }
    }else if(window.attachEvent){
        return function(){
            dom.attachEvent('on'+type, fn, false);
        }
    }
})();
// 加载时执行的是重定于函数， 之后执行的是具体分支，不需要从新判断

// 惰性执行
var addEvent = function(dom, type, fn){
    if(window.addEventListener){
        // 使用重新赋值的方式重新定于，return 会跳出运行
        addEvent function(dom, tyoe, fn){
            dom.addEventListener(type, fn, false);
        }
    }else ...
    ...
    // 注意以上只是进行了重定于，没有执行最终的绑定
    addEvent(dom, type, fn);// 最后运行一次进行绑定
}

延迟计算

原理：通过闭包保存累加参数

// 例子：计算加班时间
var monthTime = 0; // 创建全局变量
function overtime(time) {
 return monthTime += time;
}
overtime(3.5);    // 第一天
overtime(4.5);    // 第二天
overtime(2.1);    // 第三天
//...
console.log(monthTime);  // 10.1

// 柯里化 累计参数
var overtime = (function() {
  var args = [];
  return function() {
    if(arguments.length === 0) {
      var time = 0;
      for (var i = 0, l = args.length; i < l; i++) {
        time += args[i];
      }
      return time;
    }else {
      [].push.apply(args, arguments);
    }
  }
})();

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