我按我的理解总结下JavaScript闭包吧：

闭包就是一个函数引用另一个函数的变量，因为变量被引用着所以不会被回收，因此可以用来封装一个私有变量。这是优点也是缺点，不必要的闭包只会增加内存消耗。

或者说闭包就是子函数可以使用父函数的局部变量，还有父函数的参数。

理解闭包可以将以上代码分解如下：

function outerFunction() {
    var counter = 0;
    function innerFunction(){
        return counter += 1;
    }
    return innerFunction;
    /*
     注意 typeof innerFunction 是：function；而typeof innerFunction（）是number；
    */
}
var add = outerFunction();

/* 
调用 outerFunction()返回的是内部函数innerFucntion,那么调用几次add()将调用几次
内部函数inner Function，内部函数公用了counter，所以能够计数,所以说闭包就是将内部嵌套函数变成外部可调用的。
*/

add();
add();
add();

闭包就是个bug。我相信作者在写javascript的时候都没想到用户会这么用。

闭包其实是利用了一个变量退出作用域的时候，暂时没有被销毁，它的值还在，如果后面有变量也叫这个名字，那这个数据会被重新利用起来。你会发现，后面你使用的这个名字一样的变量是有初值的。下面的例子可以看出问题来。

<p>局部变量计数。</p>
<button type="button" onclick="myFunction()">计数!</button>
<p id="demo">0</p>
<script>
{
    var tmp = 2; //理论上在退出语句块后，这个变量要被释放掉的。包括内存可能被回收。但事实并非如此，会影响后面和他同名的变量
}

var add = (function () {
    //var counter = 0; //这里注释掉.其实和上面的tmp一样的道理。这里在函数自己执行完后就应该销毁了的。
    //return function () {return counter  += 1;} //这里的counter已经不是上面的counter了，是一个全局变量。有初值，受上面影响，初值为0
    return function () {return tmp += 1;} //这里tmp就是个全局变量。它是有初值的。为上面的2

})();
function myFunction(){
    document.getElementById("demo").innerHTML = add();//3
    document.getElementById("demo").innerHTML = add();//4
    document.getElementById("demo").innerHTML = add(); //5
}

</script>

尝试一下 »

执行上面的代码可以看的很清楚。计数器一样正常工作。

所以，闭包就是利用了个bug: 退出作用域的变量不会立即销毁。会影响后面的同名变量。

但不知道后面的javascript版本会不会修改这种机制。

所以代码这么写是不可靠的。太依赖于javascript的内部实现了。

其实要实现全局计数器的需求。正常的做法是:

定义一个全局对象。这个对象定义自己的属性和方法add。

用的时候 对象.add 就可以了。这个才正常。

上面用闭包的方式太过巧妙，给人的感觉就是在夹缝中求生存。用起来也不舒服吧。

针对 5楼、6楼 的一些错误进行指明：

5楼：{ var tmp = 2 } JS 中语句块不能独立作用域，这样写等同于声明了一个全局变量 tmp = 2，所以不存在该语句块内代码执行完毕后 tmp 就被销毁的情况。

6楼：变量 add，以及 add 的 count 属性、plus() 方法都是公共的，这意味着其他代码可以直接修改你的 count 属性，造成不必要的麻烦

闭包要解决的问题是：一个函数可以拥有私有变量，并且外部可以通过闭包访问该私有变量，如特权方法（类似 JavaBean 的写法）：

<script>
function Student(value) {
    var name = value;
    this.getName = function() { return name; };
    this.setName = function(value) {name = value; };
}
<script>

加上了注释就好懂了：

var add =function () {
    var counter = 0;
    window.alert("父方法"); // 只有在 add 赋值时执行一次 
    return function () {
        window.alert("子方法");  // 每次执行 add() 都会执行
        return counter += 1;

    }    
    // counter 作用域在父函数中, 自然在其子函数中也能使用,但因为
    // 子函数还需要使用了count, 所以 count 不随着父函数一起释放。    
    // 利用在 function(){}() 的形式自动执行一遍父匿名函数, 赋给 add 子方法。
}();

function myFunction(){
    document.getElementById("demo").innerHTML = add();  //这里add()执行的就是子方法
}

尝试一下 »

5 楼：{ var tmp = 2 } JS 中语句块不能独立作用域，这样写等同于声明了一个全局变量 tmp = 2，所以不存在该语句块内代码执行完毕后 tmp 就被销毁的情况。

变量 add，以及 add 的 count 属性、plus() 方法都是公共的，这意味着其他代码可以直接修改你的 count 属性，造成不必要的麻烦。

闭包要解决的问题是：一个函数可以拥有私有变量，并且外部可以通过闭包访问该私有变量，如特权方法（类似 JavaBean 的写法）。

针对以上言论，需要反驳一下。

6 楼：变量 add，以及 add 的 count 属性、plus() 方法都是公共的，这意味着其他代码可以直接修改你的 count 属性，造成不必要的麻烦。

这句话，本身就存在问题，6楼是使用new构造了一个object，并且再对object的属性和方法进行赋值，后面直接onclick 调object.method()就行了，所谓的方法都是公开的，这个的确，但是要知道纵使是公开的，也必须使用这个对象访问或者修改才行，而不是所谓的直接可以修改。

var count;
var myObj=new Object;
myObj.count=2; //这里的myObj.count与上面声明的count可不是一个东西。

另外：

<script>
function Student(value) {
    var name = value;
    this.getName = function() { return name; };
    this.setName = function(value) {name = value; };
}
<script>

以上代码，难道不觉得很像是在声明一个对象？并且为了使用所谓的 function 的闭包，还非得使用下 this 关键词，到最后还需要使用 new 构造下 Student，并且为了保证能对该函数的私有变量 name 赋值，还搞了个函数的变量传过去，用起来真的是非常别扭，并且，这个方法好像在全局也都可以通过 Student 来访问吧？

<script>
function Student(value) {
    var name = value;
    this.getName = function() { return name; };
    this.setName = function(value) {name = value; };
}
myStu=new Student("name");
//我是不是可以在script内任意一个地方通过myStu.setName("name")来修改name值？
<script>

所以，其实核心的需求就是，我可以搞一个局部的变量，并且这个变量的生命周期还必须是类全局性质的，但又需要与全局变量区分开，那就直接用对象咯，声明一个对象，再定义下这个对象的某个属性值，那这个属性值变量本来就必须通过这个对象来访问，也即已经达到了将这个变量限制在这个对象的范围内。

这个时候，又何必多次一举，非得使用所谓的闭包，更何况，你不觉得如果把一个函数定义为一个对象的方法，本身就已经是一种闭包了吗？为啥还非得用 function 达到？

闭包是调用私有属性的接口。作为一个一直学习C++的程序员，看到这个立即热泪盈眶。

好吧，但在此看到这里爆发的争论，我希望提一点：闭包是实现面向对象所必须的。

实际上，11楼根本未能理解闭包，甚至未能理解面向对象的含义。面向对象的基本要素是封装性：也许我们需要private的变量，也就是不能够直接改变只能借由方法改变的属性。而所谓“用对象就能取代闭包”，但是闭包实际上真正的意义应当用在对象构造器中的。

比如，我们希望对象有一个属性，只允许增加不许减少，而且每次只能用add函数给它加上某个偶数。这时闭包就体现了其用处。这个例子可以说是比较统一的解决了上面所提出的所有问题。

function NumPro(val){
    var counter=val;
    this.add=function(num){
        if(num%2==0) counter+=num;
    }
    this.num=function(){
        return counter;
    }
}
//alert(counter);      //报错
alert(NumPro.counter); //输出undefined(显而易见的)
var a=new NumPro(0);
alert(a.counter);      //输出undefined(不在this中)
alert(a.num());        //输出0
a.add(2);
alert(a.num());        //输出2
a.add(1);
alert(a.num());        //输出2(仅允许偶数)
a.add(10);
alert(a.num());        //输出12
var b=new NumPro(-2);
alert(b.num());        //输出-2

显然，闭包并不仅仅是由于“作用域中的变量不会销毁”——直接输出变量会直接报错，也不能通过函数名访问属性；在两个对象中所输出的值没有任何关系。同时，它又能限制对属性的直接操作——不在this中的变量无法从外部访问。

因此，闭包是被设计好的，并不是一个bug。实际上，如果接触过Java或其它面向对象语言会有很深的感触——Javascript 的面向对象往往出人意料（它甚至没有Class）。但这不意味着它不能实现其它语言中的private效果。这样看，此处的闭包仅仅是把this.counter=num改成var counter=num而已。

当然，闭包不完全是如此，比如正文中返回一个函数（名）的巧妙方法。不过，闭包意味着函数中的私有变量不会立即销毁，可被内嵌的函数访问。这就足够了。

另外，实验证明函数不仅仅可访问上一层函数的私有变量——父函数的父函数，以及更上层函数的变量都可访问（但不推荐这样做……这似乎往往只是降低代码可读性）。但是，如果使用：

NumPro.prototype.numEx=function(){
    return counter;
}

如果counter是NumPro函数内定义的，这个函数使用后将会报错（它的原型函数显然不含有counter变量，即使含有也不清楚如何处理）。

在 ES6 增加了 let 关键字后，感觉闭包可以用下面的方式实现：

{
    let counter=0;
    function fun(){
        document.getElementById("demo").innerHTML=(counter+=1);
    }
}

这样在代码块之外的函数不能调用 counter，同时 fun() 也能只调用一次 counter=0。