JavaScript里的闭包是什么？应用场景有哪些？

var foo = ( function() {
    var secret = 'secret';
    // “闭包”内的函数可以访问 secret 变量，而 secret 变量对于外部却是隐藏的
    return {
        get_secret: function () {
            // 通过定义的接口来访问 secret
            return secret;
        },
        new_secret: function ( new_secret ) {
            // 通过定义的接口来修改 secret
            secret = new_secret;
        }
    };
} () );

foo.get_secret (); // 得到 'secret'
foo.secret; // Type error，访问不能
foo.new_secret ('a new secret'); // 通过函数接口，我们访问并修改了 secret 变量
foo.get_secret (); // 得到 'a new secret'

If you can't explain it to a six-year-old, you really don't understand it yourself.

从前：
有一位公主......

function princess() {

闭包就是由函数创造的一个词法作用域，里面创建的变量被引用后，可以在这个词法环境之外自由使用。（ https://secure.wikimedia.org/wikipedia/zh/w/index.php?title=%E9%97%AD%E5%8C%85_%28%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%29&variant=zh-cn ）

闭包通常用来创建内部变量，使得这些变量不能被外部随意修改，同时又可以通过指定的函数接口来操作。 什么是闭包？

　　闭包（Closure）这个词的意思是封闭，将外部作用域中的局部变量封闭起来的函数对象称为闭包。被封闭起来的变量与封闭它的函数对象有相同的生命周期。

什么是函数对象？

　　函数对象是作为对象来使用的函数，这里的对象是指编程语言操作的数据。

函数对象与闭包

　　函数对象不一定是闭包。

　　C 语言中，可以获取一个函数的指针，并通过指针间接调用此函数。这就是 C 语言中的对象（函数对象也是对象）。但 C 语言中的函数对象不是闭包——它不能访问外部作用域的局部变量。

　　Javascript 中，每个函数都有一个与之相关联的作用域链。每次调用 JavaScript 函数的时候，都会为之创建一个新的对象用来保存局部变量，并把这个对象添加至作用域链中。当函数返回时，再将这个对象删除，此对象会被当做垃圾回收。但如果这个函数定义了嵌套的函数，并将它存储在某处的属性里，就意味着有了一个外部引用指向这个嵌套的函数。它就不会被当作垃圾回收，它所指向的变量绑定对象同样不会被回收。

　　由此可见，JavaScript 中的函数对象是闭包——可以把外部作用域的局部变量“封闭”起来。

什么是对象？

　　面向对象中的“对象”是指问题空间中的元素（猫、狗）及其在解空间中的表示（new Cat(); new Dog()）。对象是过程（函数）与数据的结合。

对象与闭包

　　对象是在数据中以方法的形式内含了过程，闭包是在过程中以环境的形式内含了数据。所谓“闭包是穷人的对象”、“对象是穷人的闭包”，就是说使用其中的一种方式，就能实现另一种方式能够实现的功能。

应用场景

　　保护函数内的变量安全：如迭代器、生成器。

　　在内存中维持变量：如果缓存数据、柯里化。

----------------------------------------------

个人总结，内容根据《代码的未来》、“犀牛书”、以及《Thinking in Java》整理。

举个例子来说明一下：

function Counter(start) {
var count = start;
return {
increment: function() {
count++;
}, //function increment

get: function() {
return count;
} //function get
} // return
} //function Counter

var foo = Counter(4);
foo.increment();
foo.get(); // 5

这里，Counter 函数返回两个闭包，函数 increment 和函数 get。 这两个函数都维持着 对外部作用域 Counter 的引用，因此总可以访问此作用域内定义的变量 count.

（示例来自文章：http://bonsaiden.github.com/JavaScript-Garden/ ） 虽然很多人回答了，但是还是按照自己的思维逻辑再整理一下思路。以下答案是参考《JavaScript权威指南》做的思路整理。

------------------- 长文预警 -------------------------

先说结论。闭包，简单说是指：函数对象本身和这个函数关联的作用域链的结合

上面的定义可能听不懂，为了详细说明这个概念，需要先解释清楚JavaScript中作用域相关的概念。

变量作用域

变量作用域是一个变量在定义后在源码中可见的范围。

JavaScript中存在两种变量作用域：

全局作用域：全局变量具有全局作用域，在整个JavaScript代码中都可见

本地作用域：

• 在函数中定义的变量就是本地变量，这些变量具有本地作用域，他们在其被定义的函数体内部完全可见，函数的参数也算作该函数的本地变量。
• 本地变量可以覆盖同名的全局变量
• 函数可以嵌套，且每一个函数都具有自己的本地作用域环境。

例子：

/**
 * 全局变量，全局可见
 */
var globalVar = 'global Scope';
var anotherGlobalVar = 'another global var'

function fn(){
     var localVar = 'local Scope';
     var anotherGlobalVar = 'global override';
     console.log( localVar );
     console.log( globalVar );
     console.log( anotherGlobalVar );
}

fn(); // 将

输出: 'local Scope' 'globalScope' 'global override' console.log( localVar ); // 报错, localVar 不存在 JavaScript 中的闭包与其 Scope Chain 特性真是密不可分的.
JavaScript 中的闭包:
例子:
def foo() {
var a = 1;
def bar() {
a = a + 1;
alert(a);
}
return bar;
}

var closure = foo(); // 这个时候返回的是 bar() 这个函数外加其包上的变量 a;
var closure2 = foo(); // 这里同样生成了另外一个闭包(实例)
closure(); // 2
closure2(); // 2 , 绑定了另外一份变量 a
closure(); // 3

对于常规的 foo() 方法来说, 在其内部的变量 a 的存在应该在 foo() 方法执行完毕以后就消失了, 但是 foo() 方法返回了一个新的方法 bar(), 而这个方法却访问到了 foo() 方法的变量 a (JavaScript 通过 Scope Chain 访问到父级属性), 而方法 bar() 的存在延长了变量 a 的存在时间, 类似与将变量 a 关闭在了自己的作用域范围内一样, 只要方法 bar() 没有失效, 那么变量 a 则会一直伴随着方法 bar() 存在, 而变量 a 与方法 bar() 的这样存在形式被称为闭包;

闭包的应用:
在我看来, 虽然时常听到闭包这个概念, 但真正的应用还真不是很多, 也没看到或者想到比较经典的应用. 在 JavaScript 中, 使用得最多的, 恐怕还是将 function 作为 first class 的情况使用, 就好比你可以 var a = new Number(0); 可以将 a 当作函数的参数不断的进行传递, 你也可以 var f = new Function(arg1, arg2...., functionBody) [new Function("x", "y", "return (x + y)/2")] 来定义函数, 然后将 f 作为参数在函数中不断的传递; 但我一般不会让这个 function 产生闭包来进行传递, 而是会传递一个独立的 function 避免写多了自己都忘记是哪个了.

JavaScript 闭包的实现:
如开篇所说, JavaScript 中的闭包实现与 JavaScript 的 Scope Chain 是密不可分的. 首先在 JavaScript 的执行中会一直存在一个 Execute Context Stack (想想 JavaScript 解释器在看到一个 alert(x) 的时候, 如果没有上下文他怎么知道这个 x 是什么?), Execute Context Stack 中最下面一个一定是 GlobalContext, 而在每一个函数的执行开始就会向这个 stack 中压入一个此 Function 的 Execution Context; 而一个 Execution Context 的组成分为三部分:
1. Variable Object: 存储方法内的变量 vars, 方法传入的参数, 函数内定义的函数等等(函数表达式不保存), Variable Object 在任何时候是不可以被直接访问到的, 当然不同的 JS 引擎提供了访问接口就说不定了;
2. Scope Chain: 这个函数执行的时候用以寻找值的 Scope Chain, 这个 Scope Chain 由 Variable Object + All Parent Scopes 组成, Variable Object 会放在这个 Scope Chain 的最前面, 这也是为什么函数内的变量会被最先找到;
3. thisValue, 函数被调用的时候的 this 对象, 存储的就是函数的调用者(caller)的引用;

对于 Variable Object 在不同的情况下会有不同的定义, 例如在全局的时候被称为 Global Object, 而在函数中则被称为 Activation Object 激活对象;

正是由于有了 Execution Context 中的 Scope Chain, JavaScript 才能够使得在方法 bar()
的内部访问到方法 foo() 中的变量 a, 才能够使方法 bar() 将变量 a 关闭在自己的作用范围内不让他随 foo() 方法的执行完毕而销毁;

参考资料:
ECMA-262-3 in detail. Chapter 1 ~ 6
http://dmitrysoshnikov.com/ecmascript/chapter-1-execution-contexts/ 闭包的正确称谓是 first-class function with lexical scope。

First-class function 决定了函数可以在另一个函数内部被定义，并且作为 return value 返回。
Lexcial scope 指：当一个名称不是参数也不是局部变量的时候，VM 会从该函数定义的函数运行时的局部变量中绑定。如果仍然没有再向上类推（最终所有函数都是在 global chunk 运行时被定义，所以最后都会从 global 变量中绑定）。

Structure and Interpretation of Computer Programming 的第三章的 environment model 是对闭包最精确的描述。每个函数被定义时有一个 bound environment，每个函数每次被调用时有一个 created environment。一个函数定义时的 bound environment 是这个函数的外层函数被调用时的 created environment。局部变量在 created environment 中，闭包变量在 bound environment 中。 说个应用场景。
利用闭包可以给对象设置私有属性并利用特权(Privileged)方法访问私有属性。

  var Foo = function(){
      var name = 'fooname';
      var age = 12;
      this.getName = function(){
          return name;
      };
      this.getAge = function(){
          return age;
      };
  };
  var foo = new Foo();

  foo.name;        //  => undefined
  foo.age;         //  => undefined
  foo.getName();   //  => 'fooname'
  foo.getAge();    //  => 12

2015年中秋节更新：
闭包是由于函数调用栈与作用域链不一致导致的。
等我加完班回去再用电脑详细叙述......

------------------------------
闭包就是：一个函数和它所引用的外部变量组成的实体。
由于外部变量被引用了，所以它的生命被延长。这带来了很多有趣的性质。可以说，外部函数是它的生母，闭包函数是它的养母。
正像MDN里说的，闭包把一个函数和一个(或多个)变量联系起来了，就像Java里的对象一样，即行为和属性的组合体。
所以说，闭包其实就是一个函数啊，只不过它绑定了一个变量，比那些没有绑定变量的函数更NB一点。

有个比较特殊的情况就是：N个函数引用了同一个外部变量。这样就形成了N个闭包，但是由于它们共享外部变量，所以要特别注意。比如，经常犯的一个错误就是在循环中定义闭包，它们都引用了循环变量。看起来好像它们引用了不同的值，实际上不是，它们引用的是同一个变量，其值就是循环变量最终值。因为js是单线程的，所以闭包函数肯定是在循环结束后才会被执行的，所以那时它们引用的那个变量的值是一样的。
解决办法就是重新构造闭包，使他们各自引用不同的变量，每个变量被初始化为不同的值。

另外还要注意，闭包函数所引用的外部变量与它的局部变量是不同的。它引用的外部变量是伴随它的整个生命周期的，从它被定义开始，一直陪伴这个函数到它被销毁时结束。但是，它的局部变量只有在它被调用时才会创建，调用结束就会消失。

请批评指正！