var n=;//定義全局變量n
function f(){
　　alert("在函數(shù)內部訪問全局變量n，n="+n);//在函數(shù)內部訪問全局變量n
}
f(); // 

function f(){
　　var n=;//在f函數(shù)內部定義局部變量n
}
alert("在函數(shù)外部訪問局部變量n，n="+n); //在函數(shù)外部訪問局部變量n，錯誤：n未定義

function f(){
　　n=;
}
f();
alert("n在f1函數(shù)內部沒有使用var來聲明，此時n就是一個全局變量，\r\n證明：n="+n+"，window.n==n的結果是："+(window.n==n)); 

function f(){
　　var n=;//f函數(shù)內部的局部變量n
//在f函數(shù)內部定義一個f函數(shù)
　　function f(){
//在f函數(shù)內部是可以訪問局部變量n的
　　　　alert(n); // 
　　}
}

function f(){
　　　　var n=;//局部變量n
//在f函數(shù)內部聲明的f函數(shù)
　　　　function f(){
　　　　　　alert(n);
　　　　}
　　　　return f;//將f函數(shù)作為f函數(shù)的返回值
　　}
　　var result=f();//f調用完后的返回值是一個f函數(shù)，此時result就是f函數(shù)
　　result(); // 999，調用f2函數(shù) 

function f(){
　　　　var n=;
//nAdd是一個沒有使用var聲明的全局變量，這個變量現(xiàn)在指向了在f函數(shù)內部聲明的一個匿名函數(shù)
　　　　nAdd=function(){n+=}
　　　　function f(){
　　　　　　alert(n);
　　　　}
　　　　return f;
　　}
　　var result=f();//result就是f函數(shù)
　　result();//第一次調用result函數(shù) 
　　nAdd();//nAdd代表的就是在f函數(shù)內部聲明的一個匿名函數(shù)，nAdd()就是在調用匿名函數(shù)
　　result();//第二次調用result函數(shù) 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全局對象、全局函數(shù)以及全局變量均自動成為window對象的成員。
全局變量是window對象的屬性。
全局函數(shù)是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函數(shù)
//object對象的getNameFunc方法的返回值是一個匿名函數(shù)
　　　　　　return function(){
//此時這個this指的是哪個對象呢，指的是window對象，哪個對象調用this所在的函數(shù)，this指的就是哪個對象。
//證明匿名函數(shù)里面的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代表的就是匿名方法，現(xiàn)在相當于給匿名方法起了一個名字叫retFn，
此時的retFn函數(shù)自動成為了window對象的一個函數(shù)
*/
var retFn = object.getNameFunc();
alert(retFn());//調用返回的匿名方法，那么是誰在調用這個匿名方法呢？是window對象
//證明：retFn函數(shù)是window對象的一個函數(shù)
alert("window.retFn()："+window.retFn());//能用window.retFn()(對象名.方法名)的形式去調用retFn方法，那么就證明了retFn函數(shù)是window對象的一個函數(shù) 

var name = "The Window";//全局變量name
//全局對象object
var object = {
　　　　name : "My Object",
　　　　getNameFunc : function(){
/*
此時這個this代表的是哪個對象呢，this此時代表的是object對象，哪個對象調用this所在的函數(shù)，this指的就是哪個對象
執(zhí)行完that = this后，此時that也代表object對象
*/
var that = this;//that是在getNameFunc函數(shù)里面聲明的一個局部變量
//證明getNameFunc函數(shù)里面的this代表的是object對象而不是window
alert("this==object的結果是："+(this==object));
alert("this==window的結果是："+(this==window));
//證明that代表的是object對象
alert("that==object的結果是："+(that==object));
　　　　　　return function(){
/*that是在getNameFunc函數(shù)里面聲明的一個局部變量,
正常情況下getNameFunc函數(shù)調用完成后，that這個局部變量就會被JavaScript的GC回收，釋放掉that這個局部變量所占用的內存空間，
但是現(xiàn)在that卻能一直正常使用，沒有被回收，
原因就在于getNameFunc是這個匿名函數(shù)的父函數(shù)，而getNameFunc函數(shù)調用完后會將這個匿名函數(shù)返回并被賦給了一個全局變量retFn，這導致匿名函數(shù)始終在內存中，
而匿名函數(shù)的存在依賴于getNameFunc函數(shù)，因此getNameFunc函數(shù)也始終在內存中，不會在調用結束后，被垃圾回收機制（garbage collection）回收。
既然getNameFunc函數(shù)始終在內存中，那么在getNameFunc函數(shù)內部聲明的that局部變量在內存中也會一直存在，既然存在，那么當然可以繼續(xù)使用了。
*/
　　　　　　　　return that.name;//that代表的是object對象，那么that.name訪問的自然就是object對象的名字"My Object"
　　　　　　};
　　　　}
　　};
var retFn = object.getNameFunc();//調用完getNameFunc方法后，返回一個匿名方法，此時retFn代表的就是匿名方法，現(xiàn)在相當于給匿名方法起了一個名字叫retFn
　　alert(retFn()); 

<script type="text/javascript">
function A(){
var i = ;//聲明在A函數(shù)內部的局部變量i
//聲明在A函數(shù)的內部的子函數(shù)b
function b(){
alert("i = "+(++i));//在子函數(shù)b內部訪問聲明在A函數(shù)內部的局部變量i
}
return b;//返回b這個函數(shù)的地址
}
/*
在執(zhí)行完var c = A()后，變量c實際上是指向了函數(shù)b,b中用到了變量i,
再執(zhí)行c()后會彈出一個窗口顯示i的值(第一次為)，
這段代碼其實就是創(chuàng)建了一個閉包，
因為函數(shù)a外的變量c引用了函數(shù)a內部的函數(shù)b
也就是說：當函數(shù)a的內部函數(shù)b被函數(shù)a外的一個變量引用的時候，
就創(chuàng)建了一個所謂的"閉包"
閉包的作用就是在a執(zhí)行完并返回后，
閉包使得JavaScript的垃圾回收機制GC不會收回a所占用的資源，
因為a的內部函數(shù)b的執(zhí)行需要依賴a中的變量
*/
A();//此時內存中肯定會有i的空間，當執(zhí)行完A()之后，GC就會回收為i分配的內存空間
var c = A();//這種用法，GC不會把i當成垃圾處理掉
c();//相當于調用b()，結果是：i=
c();//結果是：i=
c();//結果是：i=
</script>