JavaScript闭包（Closure）核心机制与实战详解

var n=;//定义全局变量n
function f(){
　　alert("在函数内部访问全局变量n，n="+n);//在函数内部访问全局变量n
}
f(); // 

function f(){
　　var n=;//在f函数内部定义局部变量n
}
alert("在函数外部访问局部变量n，n="+n); //在函数外部访问局部变量n，错误：n未定义

function f(){
　　n=;
}
f();
alert("n在f1函数内部没有使用var来声明，此时n就是一个全局变量，\r\n证明：n="+n+"，window.n==n的结果是："+(window.n==n)); 

function f(){
　　var n=;//f函数内部的局部变量n
//在f函数内部定义一个f函数
　　function f(){
//在f函数内部是可以访问局部变量n的
　　　　alert(n); // 
　　}
}

function f(){
　　　　var n=;//局部变量n
//在f函数内部声明的f函数
　　　　function f(){
　　　　　　alert(n);
　　　　}
　　　　return f;//将f函数作为f函数的返回值
　　}
　　var result=f();//f调用完后的返回值是一个f函数，此时result就是f函数
　　result(); // 999，调用f2函数 

function f(){
　　　　var n=;
//nAdd是一个没有使用var声明的全局变量，这个变量现在指向了在f函数内部声明的一个匿名函数
　　　　nAdd=function(){n+=}
　　　　function f(){
　　　　　　alert(n);
　　　　}
　　　　return f;
　　}
　　var result=f();//result就是f函数
　　result();//第一次调用result函数 
　　nAdd();//nAdd代表的就是在f函数内部声明的一个匿名函数，nAdd()就是在调用匿名函数
　　result();//第二次调用result函数 1000 

var name = "The Window";
　　var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
　　　　　　return function(){
　　　　　　　　return this.name;
　　　　　　};
　　　　}
　　};
　　alert(object.getNameFunc()()); 

var name = "The Window";
　　var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
　　　　　　var that = this;
　　　　　　return function(){
　　　　　　　　return that.name;
　　　　　　};
　　　　}
　　};
　　alert(object.getNameFunc()()); 

/*
在JavaScript中，我们声明的JavaScript全局对象、全局函数以及全局变量均自动成为window对象的成员。
全局变量是window对象的属性。
全局函数是window对象的方法。
*/
var name = "The Window";//声明一个全局变量name，此时这个全局变量name就自动成为了window对象的一个属性
//证明：
alert("window.name："+window.name);//能用window.name(对象名.属性名)的形式去访问name，那么就证明了这个全局变量name就自动成为了window对象的一个属性
//声明全局对象object，此时这个全局变量object就自动成为了window对象的一个属性
var object = {
　name : "My Object",//object对象的属性name
　　　　getNameFunc : function(){//object对象的getNameFunc函数
//object对象的getNameFunc方法的返回值是一个匿名函数
　　　　　　return function(){
//此时这个this指的是哪个对象呢，指的是window对象，哪个对象调用this所在的函数，this指的就是哪个对象。
//证明匿名函数里面的this代表的是window对象而不是object
alert("this==object的结果是："+(this==object));
alert("this==window的结果是："+(this==window));
　　　　　　　　return this.name;//既然this代表的是window对象，那么this.name访问的自然就是window对象的名字"The Window"
　　　　　　};
　　　　}
};
//证明：全局对象object是window对象的一个属性
alert("window.object："+window.object);
alert("window.object.name："+window.object.name);
/*
调用完getNameFunc方法后，返回一个匿名方法，
此时retFn代表的就是匿名方法，现在相当于给匿名方法起了一个名字叫retFn，
此时的retFn函数自动成为了window对象的一个函数
*/
var retFn = object.getNameFunc();
alert(retFn());//调用返回的匿名方法，那么是谁在调用这个匿名方法呢？是window对象
//证明：retFn函数是window对象的一个函数
alert("window.retFn()："+window.retFn());//能用window.retFn()(对象名.方法名)的形式去调用retFn方法，那么就证明了retFn函数是window对象的一个函数 

var name = "The Window";//全局变量name
//全局对象object
var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
/*
此时这个this代表的是哪个对象呢，this此时代表的是object对象，哪个对象调用this所在的函数，this指的就是哪个对象
执行完that = this后，此时that也代表object对象
*/
var that = this;//that是在getNameFunc函数里面声明的一个局部变量
//证明getNameFunc函数里面的this代表的是object对象而不是window
alert("this==object的结果是："+(this==object));
alert("this==window的结果是："+(this==window));
//证明that代表的是object对象
alert("that==object的结果是："+(that==object));
　　　　　　return function(){
/*that是在getNameFunc函数里面声明的一个局部变量,
正常情况下getNameFunc函数调用完成后，that这个局部变量就会被JavaScript的GC回收，释放掉that这个局部变量所占用的内存空间，
但是现在that却能一直正常使用，没有被回收，
原因就在于getNameFunc是这个匿名函数的父函数，而getNameFunc函数调用完后会将这个匿名函数返回并被赋给了一个全局变量retFn，这导致匿名函数始终在内存中，
而匿名函数的存在依赖于getNameFunc函数，因此getNameFunc函数也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。
既然getNameFunc函数始终在内存中，那么在getNameFunc函数内部声明的that局部变量在内存中也会一直存在，既然存在，那么当然可以继续使用了。
*/
　　　　　　　　return that.name;//that代表的是object对象，那么that.name访问的自然就是object对象的名字"My Object"
　　　　　　};
　　　　}
　　};
var retFn = object.getNameFunc();//调用完getNameFunc方法后，返回一个匿名方法，此时retFn代表的就是匿名方法，现在相当于给匿名方法起了一个名字叫retFn
　　alert(retFn()); 

<script type="text/javascript">
function A(){
var i = ;//声明在A函数内部的局部变量i
//声明在A函数的内部的子函数b
function b(){
alert("i = "+(++i));//在子函数b内部访问声明在A函数内部的局部变量i
}
return b;//返回b这个函数的地址
}
/*
在执行完var c = A()后，变量c实际上是指向了函数b,b中用到了变量i,
再执行c()后会弹出一个窗口显示i的值(第一次为)，
这段代码其实就是创建了一个闭包，
因为函数a外的变量c引用了函数a内部的函数b
也就是说：当函数a的内部函数b被函数a外的一个变量引用的时候，
就创建了一个所谓的"闭包"
闭包的作用就是在a执行完并返回后，
闭包使得JavaScript的垃圾回收机制GC不会收回a所占用的资源，
因为a的内部函数b的执行需要依赖a中的变量
*/
A();//此时内存中肯定会有i的空间，当执行完A()之后，GC就会回收为i分配的内存空间
var c = A();//这种用法，GC不会把i当成垃圾处理掉
c();//相当于调用b()，结果是：i=
c();//结果是：i=
c();//结果是：i=
</script>