3.1 闭包

函数对象：函数是一等对象，可以四处传递

3.1.1 变量的作用域

3.1.2 变量的生存周期

经典的 for循环输出i案例

3.1.3 闭包的更多作用

模式：私有变量、return function、立即执行

1. 封装变量

把一个暂存的变量从全局移动到函数内部，成为私有变量

2. 延续局部变量的寿命

上传图片
P40

var report = (function () {
    var imgs = [];
  return function (src) {
      var img = new Image();
    imgs.push(img);
    img.src = src
  }
})();
report('http://xxx.com/getUserInfo');

3.1.4 闭包和面向对象设计

闭包存放变量，相当于面向对象的对象成员变量

3.1.5 用闭包实现命令模式

1. 面向对象的方式编写

预先植入的命令接收者被当成对象的属性保存 （receiver属性）

function setCommond(commond) {}
setCommond(new OpenTvCommond(someReceiver));

2. 闭包形式的编写

命令接收者被封闭在闭包形成的环境中 （receiver参数）

function setCommond(commond) {}
setCommond(createCommond(someReceiver));

3.1.6 闭包与内存管理

有相关，但不是闭包造成内存泄漏

3.2 高阶函数

3.2.1 函数作为参数传递

1. 回调函数

异步请求的场景，尽量用promise
其它一些场景，回调函数更适合

2. Array.prototype.sort

3.2.2 函数作为返回值输出

1. isType函数的封装

2. getSingle单例模式

var getSingle = function (fn) {
    var ret;
  return ret || fn.apply(this, arguments);
};

3.3.3 高阶函数实现AOP —— 装饰者模式的实现

面向切面编程：把与核心业务逻辑无关的功能抽离出来，再通过“动态织入”的方式掺入业务逻辑模块中。

Function.prototype.before = function (beforeFn) {
    var _self = this;  // 保存原函数的引用
  return function () {  // 返回包含了原函数和新函数的“代理”函数
      beforeFn.apply(this, arguments);  // 执行新函数，修正this
    return _self.apply(this, arguments);  // 执行原函数
  }
}
Function.prototype.after = function (afterFn) {
    var _self = this;
  return function () {
      var ret = _self.apply(this, arguments);
    afterFn.apply(this, arguments)
    return ret;
  }
}
var func = function () {
    console.log(2)
};
func = func.before(function () {
    console.log(1);
}).after(function () {
    console.log(3);
});
func();

3.3.4 高阶函数的其它应用

1. currying 柯里化

var currying = function (fn) {
    var args = [];
  return function () {
      if (arguments.length === 0) {
        fn.apply(this, arguments);
    } else {
        [].push.apply(args, arguments);
      return arguments.callee;
    }
  }
}
var cost = (function () {
    var money = 0;
  for (var i = 0; i < arguments.length; i++) {
      money += arguments[i];
  }
  return money;
})();
var curryCost = currying(cost);
cost(100);
cost(200);
cost(300);
cost(); // 600