深入了解闭包

        MDN对于闭包的解释是: 一个函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包（closure）。也就是说，闭包让你可以在一个内层函数中访问到其外层函数的作用域。在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

当一个函数被创建出来时，闭包也随之产生，一个函数和他的作用域捆绑在一起这种现象就是闭包，提到闭包那就不得不提起作用域链、[[scope]]

global scope=>闭包，闭包函数，并不是一定要访问作用域的内容。

function test () {
  // fn test1 + test scope => 闭包，test1 就叫做闭包函数
  function test1 () {
    // closure 
  }
}

function test () {
  var a = 1;
  // fn test1 + test scope => 闭包，test1 就叫做闭包函数
  function test1 () {
    // closure 
    console.log(a);
  }
}

没有形成闭包，function b没有和test的环境捆绑，所以不是闭包

function b () {
  console.log(a);
}
function test () {
  var a = 1; 
  b(a);
}
test();

函数内部声明函数，其实就是一种封装性

function compute () {
  function plus (a, b) {
    return a + b;
  }
  function minus (a, b) {
    return a - b;
  }
  function mul (a, b) {
    return a * b;
  }
  function div (a,b ) {
    return a / b;
  }
  return function (type, a, b) {
    switch (type) {
      case 'plus':
        return plus(a, b);
      case 'minus':
        return minus(a, b);
      case 'mul':
        return mul(a, b);
      case 'div':
        return div(a, b);
      default:
        break;
    }
  }
}
console.log(compute()('mul', 100, 200));

==》

function compute () {
  compute.plus = function (a, b) {
    return a + b;
  }  
  compute.minus = function (a, b) {
    return a - b;
  }
  compute.mul  = function (a, b) {
    return a * b;
  }
 
  compute.div  = function (a, b) {
    return a / b;
  }
  return function (type, a, b) {
    return compute[type](a, b);
  }
}
console.log(compute()('mul', 100, 200));

==》

function compute (type, a, b) {
  compute.plus = function (a, b) {
    return a + b;
  }
  compute.minus = function (a, b) {
    return a - b;
  }
  compute.mul  = function (a, b) {
    return a * b;
  }
  compute.div  = function (a, b) {
    return a / b;
  }
  return compute[type](a, b);
}
console.log(compute('mul', 100, 200));

闭包可以来做数据结构化，比如请求一组数组，在函数中声明其他函数进行数据处理，再返回处理后的数据

class Compute {
  constructor () {
    this.a = 100;
  }
  add (b) {
    return this.a + b;
  }
  minus (b) {
    return this.a - b;
  }
}
const compute = new Compute();
console.log(compute.add(10));

上面的代码存在一个问题，a是内部变量，我们仍然可以访问，这时候需要用到闭包

const Compute = (function () {
  const a = 100;
  return class Compute {
    add (b) {
      return a + b;
    }
    minus (b) {
      return a - b;
    }
  }
})();
const compute = new Compute();
console.log(compute.add(10));

闭包缓存内部变量，不会污染全局，每个实例都存在自己的私有属性

function test () {
  let a = 1;
  function b () {
    return ++a;
  }
  return b;
}
const b = test();
console.log(b()); // 2
console.log(b()); // 3
console.log(b()); // 4

闭包应用案例

function compute () {
  const base = 1000;
	return {
    plus: function (a, b) {
      return base +  a + b;
    },
    minus: function (a, b) {
      return base -  a - b;
    },
    mul: function (a, b) {
      return base *  a * b;
    },
    div: function (a, b) {
      return base /  a / b;
    }
  }
}
const comp = compute();
console.log(comp.plus(1, 2));