ES3之closure ( 闭包 )

词法作用域中使用的域，是变量在代码中声明的位置所决定的。嵌套的函数可以访问在其外部声明的变量。

闭包是函数和声明该函数的词法环境的组合。

1 创建单个闭包

JavaScript中的函数会形成闭包。 闭包是由函数以及创建该函数的词法环境组合而成。这个环境包含了这个闭包创建时所能访问的所有局部变量。

function playGame(){
    var name = 'Ace Combat';
    function playGame_(){
        console.log('[play game]',name);
    }
    return playGame_;
}
var play = playGame();
play();

2 创建多个闭包

playA 和 playB 都是闭包。它们共享相同的函数定义，但是保存了不同的词法环境。在 playA的环境中，game 为 Ace Combat。而在 playB 中，game 则为 Neo Contra。

function playGame(game) {
    function playGame_() {
        console.log('[play game]', game);
    }
    return playGame_;
}
var playA = playGame('Ace Combat');
var playB = playGame('Neo Contra');
playA();
playB();

用闭包模拟私有方法

编程语言中，比如 Java，是支持将方法声明为私有的。JavaScript 没有这种原生支持，但我们可以使用闭包来模拟私有方法。私有方法不仅仅有利于限制对代码的访问：还提供了管理全局命名空间的强大能力，避免非核心的方法弄乱了代码的公共接口部分。

var Counter = (function() {
    var privateCounter = 0;

    function changeBy(val) {
        privateCounter += val;
    }
    return {
        increment: function() {
            changeBy(1);
        },
        decrement: function() {
            changeBy(-1);
        },
        value: function() {
            return privateCounter;
        }
    }
})();

console.log(Counter.value()); /* logs 0 */
Counter.increment();
Counter.increment();
console.log(Counter.value()); /* logs 2 */
Counter.decrement();
console.log(Counter.value()); /* logs 1 */

在一个闭包内对变量的修改，不会影响到另外一个闭包中的变量。

var makeCounter = function() {
  var privateCounter = 0;
  function changeBy(val) {
    privateCounter += val;
  }
  return {
    increment: function() {
      changeBy(1);
    },
    decrement: function() {
      changeBy(-1);
    },
    value: function() {
      return privateCounter;
    }
  }
};

var Counter1 = makeCounter();
var Counter2 = makeCounter();
console.log(Counter1.value()); /* logs 0 */
Counter1.increment();
Counter1.increment();
console.log(Counter1.value()); /* logs 2 */
Counter1.decrement();
console.log(Counter1.value()); /* logs 1 */
console.log(Counter2.value()); /* logs 0 */