javascript物件導向技術基礎(六)

範圍、閉包、類比私人屬性

先來簡單說一下變數範圍，這些東西我們都很熟悉了，所以也不詳細介紹。

Js代碼

1. var sco = "global";  //全域變數   
2. function t() {    
3.     var sco = "local";  //函數內部的局部變數   
4.     alert(sco);         //local 優先調用局部變數   
5. }   
6. t();             //local   
7. alert(sco);       //global  不能使用函數內的局部變數  

var sco = "global";  //全域變數function t() {     var sco = "local";  //函數內部的局部變數    alert(sco);         //local 優先調用局部變數}t();             //localalert(sco);       //global  不能使用函數內的局部變數

 

注意一點，在javascript中沒有塊層級的範圍，也就是說在java或c/c++中我們可以
用"{}"來包圍一個塊，從而在其中定義塊內的局部變數，在"{}"塊外部,這些變數不再起作用,
同時,也可以在for迴圈等控制語句中定義局部的變數,但在javascript中沒有此項特性:

Js代碼

1. function f(props) {   
2.     for(var i=0; i<10; i++) {}   
3.     alert(i);         //10  雖然i定義在for迴圈的控制語句中,但在函數   
4.                       //的其他位置仍舊可以訪問該變數.   
5.     if(props == "local") {   
6.         var sco = "local";   
7.     alert(sco);    
8.     }   
9.     alert(sco);       //同樣,函數仍可引用if語句內定義的變數   
10. }   
11. f("local");      //10  local   local  

function f(props) {    for(var i=0; i<10; i++) {}    alert(i);         //10  雖然i定義在for迴圈的控制語句中,但在函數                      //的其他位置仍舊可以訪問該變數.    if(props == "local") {        var sco = "local";alert(sco);     }    alert(sco);       //同樣,函數仍可引用if語句內定義的變數}f("local");      //10  local   local

 

 在函數內部定義局部變數時要格外小心:

Js代碼

1. var sco = "global";   
2. function print1() {   
3.     alert(sco);   //global   
4. }   
5. function print2() {   
6.     var sco = "local";   
7.     alert(sco);   //local   
8. }   
9. function print3() {   
10.     alert(sco);   //undefined   
11.     var sco = "local";    
12.     alert(sco);   local   
13. }   
14.   
15. print1();  //global   
16. print2();  //local   
17. print3();  //undefined  local  

var sco = "global";function print1() {    alert(sco);   //global}function print2() {    var sco = "local";    alert(sco);   //local}function print3() {    alert(sco);   //undefined    var sco = "local";     alert(sco);   local}print1();  //globalprint2();  //localprint3();  //undefined  local

 前面兩個函數都很容易理解，關鍵是第三個:第一個alert語句並沒有把全域變數"global"顯示出來，
而是undefined，這是因為在print3函數中，我們定義了sco局部變數(不管位置在何處),那麼全域的
sco屬性在函數內部將不起作用，所以第一個alert中sco其實是局部sco變數，相當於：

Js代碼

1. function print3() {   
2.     var sco;   
3.     alert(sco);   
4.     sco = "local";   
5.     alert(sco);   
6. }  

function print3() {    var sco;    alert(sco);    sco = "local";    alert(sco);}

 從這個例子我們得出，在函數內部定義局部變數時，最好是在開頭就把所需的變數定義好，以免出錯。

函數的範圍在定義函數的時候已經確定了，例如：

Js代碼

1. var scope = "global"   //定義全域變數   
2. function print() {   
3.     alert(scope);   
4. }   
5. function change() {   
6.     var scope = "local";  //定義局部變數   
7.     print();              //雖然是在change函數的範圍內調用print函數，   
8.                           //但是print函數執行時仍舊按照它定義時的範圍起作用   
9. }   
10. change();    //golbal  

var scope = "global"   //定義全域變數function print() {    alert(scope);}function change() {    var scope = "local";  //定義局部變數    print();              //雖然是在change函數的範圍內調用print函數，                          //但是print函數執行時仍舊按照它定義時的範圍起作用}change();    //golbal

 

閉包
閉包是擁有變數、代碼和範圍的運算式.在javascript中,函數就是變數、代碼和函數的範圍的組合體,因此所有
的函數都是閉包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).好像挺簡單.但是閉包到底有什麼作用呢?看一個例子。
我們想寫一個方法，每次都得到一個整數，這個整數是每次加1的，沒有思索，馬上下筆：

Js代碼

1. var i = 0;   
2. function getNext() {   
3.     i++;   
4.     return i;   
5. }   
6. alert(getNext()); //1   
7. alert(getNext()); //2   
8. alert(getNext()); //3  

var i = 0;function getNext() {    i++;    return i;}alert(getNext()); //1alert(getNext()); //2alert(getNext()); //3

 

一直用getNext函數得到下一個整數,而後不小心或者故意的將全域變數i的值設為0,然後再次調用getNext,
你會發現又從1開始了........這時你會想到,要是把i設定成一個私人變數該多好,這樣只有在方法內部才
可能改變它，在函數之外就沒有辦法修改了.下面的代碼就是按照這個要求來做得，後面我們詳細討論。
為瞭解釋方便，我們就把下面的代碼稱為demo1.

Js代碼

1. function temp() {   
2.     var i = 0;   
3.     function b() {   
4.         return ++i;   
5.     }   
6.     return b;   
7. }   
8. var getNext = temp();   
9. alert(getNext());    //1   
10. alert(getNext());    //2   
11. alert(getNext());    //3   
12. alert(getNext());    //4  

function temp() {    var i = 0;    function b() {        return ++i;    }    return b;}var getNext = temp();alert(getNext());    //1alert(getNext());    //2alert(getNext());    //3alert(getNext());    //4

 

因為我們平時所說的javascript絕大多數都是指的在用戶端(瀏覽器)下，所以這裡也不例外。
在javascript解譯器啟動時,會首先建立一個全域的對象(global object),也就是"window"所引用的對象.
然後我們定義的所有全域屬性和方法等都會成為這個對象的屬性.
不同的函數和變數的範圍是不同的,因而構成了一個範圍鏈(scope chain).很顯然，在javascript解譯器啟動時,
這個範圍鏈只有一個對象:window(Window Object，即global object).
在demo1中,temp函數是一個全域函數，因此temp()函數的範圍(scopr)對應的範圍鏈就是js解譯器啟動時的範圍鏈，只有一個window對象。
當temp執行時，首先建立一個call對象(使用中的物件)，然後把這個call對象添加到temp函數對應的範圍鏈的最前頭,這是，temp()函數
對應的範圍鏈就包含了兩個對象：window對象和temp函數對應的call object(使用中的物件).然後呢，因為我們在temp函數裡定義了變數i，
定義了函數b(),這些都會成為call object的屬性。當然，在這之前會首先給call object對象添加arguments屬性，儲存了temp()函數執行時
傳遞過來的參數。此時，整個的範圍鏈如所示:

 

同理可以得出函數b()執行時的整個範圍鏈:

 
注意在b()的範圍鏈中，b()函數對應的call object只有一個arguemnts屬性，並沒有i屬性，這是因為在b()的定義中，並沒有用var關鍵字來
聲明i屬性，只有用var 關鍵字聲明的屬性才會添加到對應的call object上.
在函數執行時，首先尋找對應的call object有沒有需要的屬性，如果沒有，再往上一級尋找，直到找到為止，如果找不到，那就是undefined了.

這樣我們再來看demo1的執行情況。我們用getNext引用了temp函數，而temp函數返回了函數b，這樣getNext函數其實就是b函數的引用。
執行一次getNext，就執行一次b()函數。因為函數b()的範圍依賴於函數temp，因此temp函數在記憶體中會一直存在。函數b執行時，首先尋找
i，在b對應的call object中沒有，於是往上一級找，在temp函數對應的call object中找到了，於是將其值加1，然後返回這個值。
這樣，只要getNext函數有效，那麼b()函數就一直有效，同時，b()函數依賴的temp函數也不會消失，變數i也不會消失，而且這個變數在temp函數
外部根本就訪問不到，只能在temp()函數內部訪問(b當然可以了).

來看一個利用閉包來類比私人屬性的例子:

Js代碼

1. function Person(name, age) {     
2.     this.getName = function() { return name; };     
3.     this.setName = function(newName) { name = newName; };     
4.     this.getAge = function() { return age; };     
5.     this.setAge = function(newAge) { age = newAge; };     
6. }     
7.      
8. var p1 = new Person("sdcyst",3);     
9. alert(p1.getName());  //sdcyst     
10. alert(p1.name);       //undefined   因為Person('類')沒有name屬性     
11. p1.name = "mypara"    //顯示的給p1添加name屬性     
12. alert(p1.getName());  //sdcyst     但是並不會改變getName方法的傳回值     
13. alert(p1.name);       //mypara     顯示出p1對象的name屬性     
14. p1.setName("sss");    //改變私人的"name"屬性   
15. alert(p1.getName());  //sss     
16. alert(p1.name);       //仍舊為mypara    

function Person(name, age) {      this.getName = function() { return name; };      this.setName = function(newName) { name = newName; };      this.getAge = function() { return age; };      this.setAge = function(newAge) { age = newAge; };  }    var p1 = new Person("sdcyst",3);  alert(p1.getName());  //sdcyst  alert(p1.name);       //undefined   因為Person('類')沒有name屬性  p1.name = "mypara"    //顯示的給p1添加name屬性  alert(p1.getName());  //sdcyst     但是並不會改變getName方法的傳回值  alert(p1.name);       //mypara     顯示出p1對象的name屬性  p1.setName("sss");    //改變私人的"name"屬性alert(p1.getName());  //sss  alert(p1.name);       //仍舊為mypara  

 

定義了一個Person類，有兩個私人屬性name，age，分別定義對應的get/set方法。
雖然可以顯示的設定p1的name、age屬性，但是這種顯示的設定，並不會改變我們
最初設計時類比出來的"name/age"私人屬性。

解釋閉包的確不是一件容易的事，在網上很多人也是利用例子來說明閉包。如果有地方說的不對，還請指正。