40分请教闭包，希望解释清晰条理

Question

首先：
function A（）{
            var a=10;
            this.test=function(){
                alert(a++);
            }
       }var oNode1=new A;
oNode1.test（）;  //   10
oNode1.test（）;  //   11var oNode2=new A;
oNode2.test（）;  //   10
oNode2.test（）;  //   11函数内部包含着函数，于是有闭包。以前我没深入的想过，不同的对象执行的结果当然不一样，这里我们确实看见，a变量被保存着，但是new出不同的对象后，a还是重新开始计算。以上并没有得到 10,11,12,13的结果。于是我认为，奥，不同的对象来调，外部的活动对象不一样，所以是2个相互独立的闭包。然后：
(function my(){
           var m=10;
           myObject=function(){}
           myObject.prototype.xx=function(){
               ++m;
               return m;
           }
       })()
       var gg=new myObject;
       var pp=new myObject;
       gg.xx();  //10
       gg.xx();   //11
       pp.xx();   //12
       pp.xx();   //13
 
因为 xx方法来自于原型，而且gg.xx==pp.xx，所以我会认为，其实外部的调用对象还是一致的，所以这里m的值因为闭包，一致保存着，作用于实例出来的各个对象。但最后：(function my(){
           var m=10;
           myObject=function(){
               this.test=function(){
                   alert(++m);
               }
           }
       })()
       var gg=new myObject;
       var pp=new myObject;
       gg.test();   //11
       gg.test();    //12
       pp.test();    //13
       pp.test();    //14虽然pp和gg是两个不同对象，gg.test和pp.test也是不同的，但是m值都在内存中保留，所以我觉得跟前面有些矛盾，或者我没有办法很好的解释，到底什么是对，什么是错。我觉得自己在一个误区里，一直没弄明白。求高人赐教。

Answer 1

function A（）{
   var a=10;
   this.test=function(){
   alert(a++);
   }
}
var oNode1=new A;
oNode1.test（）; // 10
oNode1.test（）; // 11var oNode2=new A;
oNode2.test（）; // 10
oNode2.test（）; // 11
每次new的时候里面的var a 都会重新创建（等于10） 所以没有累加 这是关键
(function my(){
   var m=10;
   myObject=function(){}
   myObject.prototype.xx=function(){
   ++m;
   return m;
   }
})()
   var gg=new myObject;
   var pp=new myObject;
   gg.xx(); //10
   gg.xx(); //11
   pp.xx(); //12
   pp.xx(); //13
 
你的 myObject 没有var 所以是全局变量
所以你外面的my() 应该意义不大
每次new myObject的时候 执行xx的时候 都是给m++ 你的m没有重新定义 所以累加，这是关键
最后
“虽然pp和gg是两个不同对象，”
虽然是“不同对象”但是都是一个引用（具体看引用类型解释这里不多说）

Answer 2

(function my(){
   var m=10;
   var myObject=function(){} //加上var 下面的new myObject; 就访问不到myObject 出错
   myObject.prototype.xx=function(){
   ++m;
   return m;
   }
})()
var gg=new myObject;
var pp=new myObject;
gg.xx(); //10
gg.xx(); //11
pp.xx(); //12
pp.xx(); //13(function my(){
   var m=10;
})()；var myObject=function(){} 
myObject.prototype.xx=function(){
++m; //这次访问不到m了 出错
return m;
}
   
var gg=new myObject;
var pp=new myObject;
gg.xx(); //10
gg.xx(); //11
pp.xx(); //12
pp.xx(); //13
变量的作用域（理解了懂了就无所谓 所谓的闭包了。一个技巧而已 个人觉得）  基本类型 引用类型  知识点就这些了

Answer 3

我闲说一下闭包的概念：闭包就是函数对象外调用函数对象内的方法和变量的函数。function fun(){
var n = 100;
}
alert(n)
这个无法  alert  出  n  ；因为函数对象外不能调用函数对象的变量。再看下面一个：function fun(){
var n = 100;
var fun1 = function (){
alert(n);
}
fun1();
}
fun();
这个就能  alert   出  n  的值。 fun1()  函数就是闭包。
再回答楼主后面两个为什么内存没有初始化的问题。
后面两个你声明的  m  是  my() 这个顶层函数对象的变量，而你每次把myObject对象实例化是在你调用了 my() 这个函数之后。所以 m 的值无法被初始化，因为一直处于被调用的状态。（PS：你写的代码没有表达出你的问题）