我們建立的每個函式都有一個 prototype(原型)屬性,這個屬性是一個指標,指向一個物件,而這個物件的用途,是包含能由特定類型的所有實例共享的屬性和方法。若按字面意思理解,prototype 就是透過呼叫建構函式而建立的那個物件實例的原型物件。使用原型物件的好處,是可以讓所有物件實例共享它所包含的屬性和方法;也就是說,不必在建構函式中定義物件實例的資訊,而可以把資訊直接添加到原型物件中,如下例:
function Person() {} Person.prototype.name = "Nicholas"; Person.prototype.age = "29"; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); }; var person1 = new Person(); person1.sayName(); //"Nicholas" var person2 = new Person(); person2.sayName(); //"Nicholas"; alert(person1.sayName == person2.sayName); //true
在此,我們把 sayName() 方法和所有屬性直接添加到 Person 的 prototype 屬性中,建構函式變成了空函式。即使如此,仍然可以透過呼叫建構函式來建立新物件,而且新物件還會具有相同的屬性和方法。但與建構函式模式不同的是,新物件的這些屬性和方法是由所有實例共享的。也就是說,person1 和 person2 訪問的都是同一組屬性和同一個 sayName() 函式。要理解原型模式的工作原理,必須理解 ECMAScript 中原型物件的性質。
無論何時,只要建立一個新函式,就會根據一組特定的規則為該函式建立一個 prototype 屬性,這個屬性指向函式的原型物件。在默認情況下,所有原型物件都會獲得一個 constructor(建構函式)屬性,這個屬性包含一個指向 prototype 屬性所在函式的指標。就拿前面的例子來說,Person.prototype.constructor 指向 Person;而透過這個建構函式,我們還可以繼續為原型物件添加其它屬性和方法。
建立了自定義的建構函式之後,其原型物件默認只會取得 constructor 屬性;至於其它方法,則都是從 Object 繼承而來的。當呼叫建構函式建立一個新實例後,該實例的內部將包含一個指標(內部屬性),指向建構函式的原型物件。在許多實作中,這個內部屬性的名字是 _proto_,而且可以透過腳本訪問到(在 Firefox、Safari、Chrome 和 Flash 的 ActionScript 中,都可以透過腳本訪問 _proto_);而在其它實作中,這個屬性對腳本則是完全不可見的。不過,要明確真正重要的一點:這個連接存在於實例與建構函式的原型物件之間,而不是存在於實例與建構函式之間。
雖然在某些實作中無法訪問到內部的 _proto_ 屬性,但在所有實作中都可以透過 isPrototypeOf() 方法來確定物件之間是否存在這種關係。從本質上來講,如果物件的 _proto_ 指向呼叫 isPrototypeOf() 方法的物件(Person.prototype),那麼這個方法就傳回 true,如下所示:
alert(Person.prototype.isPrototypeOf(person1)); //true; alert(Person.prototype.isPrototypeOf(person2)); //true;
這裡,我們用原型物件的 isPrototypeOf() 方法測試了 person1 和 person2。因為它們內部都有一個指向 Person.prototype 的指標,因此都傳回了 true。
每當程式碼讀取某個物件的某個屬性時,都會執行一次搜索,目標是具有該名字的屬性。搜索首先從物件實例本身開始:如果在實例中找到了具有該名字的屬性,則傳回該屬性的值;如果沒有找到,則繼續搜索指標指向的原型物件,在原型物件中查找具有該名字的屬性;如果在原型物件中找到了,則傳回該屬性的值。也就是說,當我們呼叫 person1.sayName() 時,會先後執行兩次搜索:首先,解析器會問「實例 person1 有 sayName 屬性嗎?」答:「沒有。」然後它繼續搜索,再問「person1 的原型有 sayName 屬性嗎?」答:「有。」於是,它就讀取那個保存在原型物件中的函式。當我們呼叫 person2.sayName() 時,將重現相同的搜索過程,得到相同的結果——這正是多個物件共享原型所保存的屬性和方法的基本原理。
前面提到過,原型最初只包含 constructor 屬性,而該屬性也是共享的,因此可以透過物件實例訪問。
雖然可以透過物件實例訪問保存在原型中的值,但卻不能透過物件實例重寫原型中的值。如果我們在實例中添加了一個屬性,而該屬性與實例原型中的一個屬性同名,那我們就在實例中建立該屬性,該屬性將會屏蔽原型中的那個屬性。來看下面的例子:
function Person() {} Person.prototype.name = "Nicholas"; Person.prototype.ae = 29; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); } var person1 = new Person(); var person2 = new Person(); person1.name = "Greg"; alert(person1.name); //"Greg" ——來自實例 alert(person2.name); //"Nicholas" ——來自原型
在這個例子中,person1 的 name 被一個新值屏蔽了。但無論訪問 person1.name 還是 person2.name 都能正常地傳回值,分別是「Greg」(來自物件實例)和「Nicholas」(來自原型)。當在 alert() 中訪問 person1.name 時,需要讀取它的值,因此會在這個實例上搜索一個名為 name 的屬性;這個屬性確實存在,於是就傳回它的值,而不必再搜索原型。當以同樣的方式訪問 person2.name 時,並沒有在實例上發現該屬性,因此會繼續搜索原型,結果在那裡找到了 name 屬性。
當為物件實例添加了一個屬性時,這個屬性就會屏蔽原型物件中保存的同名屬性;也就是說,添加這個屬性只會阻止我們訪問原型中的那個屬性,但不會修改那個屬性。即使把這個屬性值設為 null,也只會在實例中設置這個屬性,而不會恢復它指向原型的連接。不過,使用 delete 運算符則可以完全刪除實例屬性,從而讓我們能夠重新訪問原型中的屬性,如下所示:
function Person() {} Person.prototype.name = "Nicholas"; Person.prototype.age = 20; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); } var person1 = new Person(); var person2 = new Person(); person1.name = "Greg"; alert(person1.name); //“Greg” ——來自實例 alert(person2.name); //"Nicholas" ——來自原型 delete person1.name; alert(person1.name); //"Nicholas" ——來自原型
在這個修改後的例子中,我們用 delete 運算符刪除了 person1.name,之前它保存的「Greg」值屏蔽了同名的原型屬性。把它刪除以後,就恢復了原型中 name 屬性的連接。因此,接下來再呼叫 person1.name 時,傳回的就是原型中 name 屬性的值了。
使用 hasOwnProperty() 方法可以檢測一個屬性是存在於實例中,還是存在於原型中。這個方法(別忘了它是從 Object 繼承來的)只在給定屬性存在於物件實例中時,才會傳回 true。來看下面這個例子:
function Person() {} Person.prototype.name = "Nicholas"; Person.prototype.jog = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); }; var person1 = new Person(); var person2 = new Person(); alert(person1.hasOwnProperty("name")); //false person1.name = "Greg"; alert(person1.name); //"Greg" ——來自實例 alert(person1.hasOwnProperty("name")); //true alert(person2.name); //"Nicholas" ——來自原型 alert(person2.hasOwnProperty("name")); //false delete person1.name; alert(person1.name); //"Nicholas" ——來自原型 alert(person1.hasOwnProperty("name")); //flase
透過使用 hasOwnProperty() 方法,什麼時候訪問的是實例屬性、什麼時候訪問的是原型屬性就一清二楚了。呼叫 person1.hasOwnProperty("name") 時,只有在 person1 重寫 name 屬性後才會傳回 true,因為只有這時候 name 才是一個實例屬性,而非原型屬性。
有兩種方式使用 in 運算符:單獨使用,和在 for-in 迴圈中使用。單獨使用時,in 運算符會在透過物件能夠訪問給定屬性時傳回 true,無論該屬性存在於實例還是原型中。看一看下面的例子:
function Person() {} Person.prototype.name = "Nicholas"; Person.prototype.age = "29"; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); }; var person1 = new Person(); var person2 = new Person(); alert(person1.hasOwnProperty("name")); //false alert("name" in person1); //true person1.name = "Greg"; alert(person1.name); //"Greg" ——來自實例 alert(person1.hasOwnProperty("name")); //true; alert("name" in person1); //true alert(person2.name); //"Nicholas"——來自原型 alert(person2.hasOwnProperty("name")); //false alert("name" in person1); //true delete person1.name; alert(person1.name); //"Nicholas" ——來自原型 alert(person1.hasOwnProperty("name")); //false alert("name" in person1); //true;
在以上程式碼執行的整個過程中,name 屬性要麼直接在物件上訪問到,要麼是透過原型訪問到的。因此,呼叫「name」 in person1 始終都傳回 true,無論該屬性存在於實例中還是存在於原型中。同時使用 hasOwnProperty() 方法和 in 運算符,就可以確定該屬性到底是存在於物件中,還是存在於原型中,如下所示:
function hasPrototypeProperty(object, name) { return !object.hasOwnProperty(name) && (name in object); }
由於 in 運算符只要透過物件能夠訪問到屬性就傳回 true,而 hasOwnProperty() 只在屬性存在於實例中時才傳回 true,因此只要 in 運算符傳回 true 而 hasOwnProperty() 傳回 false,就可以確定該屬性是原型中的屬性。下面來看上面定義的函式 hasPrototypeProperty() 的用法:
function Person() { } Person.prototype.name = "Nicholas"; Person.prototype.age = "29"; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function () { alert(this.name); }; var person = new Person(); alert(hasPrototypeProperty(person, "name")); //true person.name = "Greg"; alert(hasPrototypeProperty(person, "name")); //false
在這裡,name 屬性先是存在於原型中,因此 hasPrototypeProperty() 傳回 true。當在實例中重寫 name 屬性後,該屬性就存在於實例中了,因此 hasPrototypeProperty() 傳回 false。
在使用 for-in 迴圈時,傳回的是所有能夠透過物件訪問的、可枚舉的屬性,其中既包括存在於實例中的屬性,也包括存在於原型中的屬性。屏蔽了原型中不可枚舉屬性(即設置了 [[DontEnum]] 標記的屬性)的實例屬性,也會在 for-in 迴圈中傳回,因為規定所有開發人員定義的屬性都是可枚舉的——只有 IE 除外。
IE 的 JScript 實作中存在一個 bug,即屏蔽了不可枚舉屬性的實例屬性不會出現在 for-in 迴圈中。例如:
var o = { toString: function () { return "My Object"; } } for (var prop in o) { if (prop == "toString") { alert("Found toString"); //在IE中不會顯示 } }
當以上程式碼運行時,應該會顯示一個警告框,表明找到了 toString() 方法。這裡的物件 o 定義了一個名為 toString() 的方法,該方法屏蔽了原型中(不可枚舉)的 toString() 方法。在 IE 中,由於其實現認為原型的 toString() 方法被打上了 [[DontEnum]] 標記就應該跳過該屬性,結果我們就不會看到警告框。該 bug 會影響默認不可枚舉的所有屬性和方法,包括 hasOwnProperty()、propertyIsEnumerable()、toLocaleString()、toString() 和 valueOf()。有的瀏覽器也為 constructor 和 prototype 屬性打上了 [[DontEnum]] 標記,但這並不是所有瀏覽器共同的做法。
讀者大概注意到了,前面例子中每添加一個屬性和方法就要敲一遍 Person.prototype。為了減少不必要的輸入,也為了從視覺上更好地封裝原型的功能,更常見的做法是用一個包含所有屬性和方法的物件字面量來重寫整個原型物件,如下例:
function Person() { } Person.prototype = { name: "Nicholas", age: 29, job: "Software Engineer", sayName: function () { alert(this.name); } };
在上面的程式碼中,我們把 Person.prototype 設為等於一個以物件字面量形式建立的新物件。最終結果相同,但有一個例外:constructor 屬性不再指向 Person 了。前面曾經介紹過,每建立一個函式,就會同時建立它的 prototype 物件,這個物件也會自動獲得 constructor 屬性。而我們在這裡使用的語法,本質上完全重寫了默認的 prototype 物件,因此 constructor 屬性也就變成了新物件的 constructor 屬性(指向 Object 建構函式),不再指向 Person 函式。此時,盡管 instanceof 運算符還能傳回正確的結果,但透過 constructor 已經無法確定物件的類型了,如下所示:
function Person() { } Person.prototype = { name: "Nicholas", age: 29, job: "Software Engineer", sayName: function () { alert(this.name); } }; var person = new Person(); alert(person instanceof Object); //true alert(person instanceof Person); //true alert(person.constructor == Person); //false alert(person.constructor == Object); //true
在此,用 instanceof 運算符測試 Object 和 Person 仍然傳回 true,但 constructor 屬性則等於 Object 而不等於 Person 了。如果 constructor 的值真的很重要,可以像下面這樣特意把它設回適當的值:
function Person() {} Person.prototype = { constructor: Person, name: "Nicholas", age: 29, job: "Software Engineer", sayName: function () { alert(this.name); } }; var person = new Person();
以上程式碼特意包含了一個 constructor 屬性,並把它的值設為 Person,從而確保了透過該屬性能夠訪問到適當的值。
alert(person instanceof Object); //true alert(person instanceof Person); //true alert(person.constructor == Person); //true alert(person.constructor == Object); //false
由於在原型中查找值的過程是一次搜索,因此我們對原型物件所做的任何修改都能夠立即從實例上反映出來——即使是建立實例之後再修改原型也照樣如此。請看下面的例子:
var person = new Person(); Person.prototype.sayHi = function () { alert("hi"); }; person.sayHi(); //"hi" (沒有問題!)
以上程式碼先建立了 Person 的一個實例,並將其保存在 person 中。然後,下一條語句在 Person.prototype 中添加了一個方法 sayHi()。即使 person 實例是在添加新方法之前建立的,但它仍然可以訪問這個新方法。其原因可以歸結為實例與原型之間的鬆散連接關係。當我們呼叫 Person.sayHi() 時,首先會在實例中搜索名為 sayHi 的屬性,在沒找到的情況下,會繼續搜索原型。因為實例與原型之間的連接只不過是一個指標,而非一個副本,因此就可以在原型中找到新的 sayHi 屬性並傳回保存在那裡的函式。
盡管可以隨時為原型添加屬性和方法,並且修改能夠立即在所有物件實例中反映出來,但如果是重寫整個原型物件,那麼情況就不一樣了。我們知道,呼叫建構函式時會為實例添加一個指向最初原型的 _proto_ 指標,而把原型修改為另外一個物件,就等於切斷了建構函式與最初原型之間的聯繫。請記住:實例中的指標只指向原型,而不指向建構函式。看下面的例子:
function Person() {} var person = new Person(); Person.prototype = { constructor: Person, name: "Nicholas", age: 29, job: "Software engineer", sayName: function () { alert(this.name); } }; person.sayName(); //error
在這個例子中,我們先建立了 Person 的一個實例,然後又重寫了其原型物件。接著在呼叫 person.sayName() 時發生了錯誤,因為 person 指向的原型中不包含該名字的屬性。
原型模式的重要性不僅體現在建立自定義類型方面,就連所有原生的引用類型,都是採用這種模式建立的。所有原生引用類型(Object、Array、String 等)都在其建構函式的原型上定義了方法。例如,在 Array.prototype 中可以找到 sort() 方法,而在 String.prototype 中可以找到 substring() 方法,如下所示:
alert(typeof Array.prototype.sort); //"function" alert(typeof String.prototype.substring); //"function"
透過原生物件的原型,不僅可以取得所有默認方法的引用,而且也可以定義新方法。可以像修改自定義物件的原型一樣修改原生物件的原型,因此可以隨時添加方法。下面的程式碼就給基本包裝類型 String 添加了一個名為 startsWith() 的方法:
String.prototype.startsWith = function (text) { return this.indexOf(text) == 0; }; var msg = "Hello world!"; alert(msg.startsWith("Hello")); //true
這裡定義的 startsWith() 方法會在傳入的文本位於字串開始時傳回 true。既然方法被添加給了 String.prototype,那麼當前環境中的所有字串就都可以呼叫它。由於 msg 是字串,而且後台會呼叫 String 基本包裝函式建立這個字串,因此透過 msg 就可以呼叫 startsWith() 方法。
盡管可以這樣做,但我們不推薦在產品化的程式中修改原生物件的原型。如果因為某個實作中缺少某個方法,就在原生物件的原型中添加這個方法,那麼當在另一個支持該方法的實作中運行程式碼時,就可能會導致命名衝突;而且,這樣做也可能意外地重寫原生方法。
原型模式也不是沒有缺點。首先,它省略了為建構函式傳遞初始化參數這一環節,結果所有實例在默認情況下都將取得相同的屬性值。雖然這會在某種程度上帶來一些不方便,但還不是原型的最大問題。原型模式的最大問題,是由其共享的本性所導致的。
原型中所有屬性是被很多實例共享的,這種共享對於函式非常合適。對於那些包含基本值的屬性倒也說得過去,畢竟透過在實例中添加一個同名屬性,可以隱藏原型中的對應屬性。然而,對於包含引用類型的屬性來說,問題就比較突出了。來看下面的例子:
function Person() {} Person.prototype = { constructor: Person, name: "Nicholas", age: 2, job: "Software Engineer", friends: ["Shelby", "Court"], sayName: function () { alert(this.name); } }; var person1 = new Person(); var person2 = new Person(); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Court,Van" alert(person2.friends); //"Shelby, Court, Van" alert(person1.friends == person2.friends); //ture
在此,Person.prototype 物件有一個名為 friends 的屬性,該屬性包含一個字串陣列。然後,建立了 Person 的兩個實例。接著,修改了 person1.friends 引用陣列,向陣列中添加了一個字串。由於 friends 陣列存在於 Person.prototype 而非 person1 中,所以剛剛提到的修改也會透過 person2.friends 反映出來。假如我們的初衷就是像這樣在所有實例中共享一個陣列,那麼對這個結果我無話可說;可是,實例一般都是要有屬於自己的全部屬性的。而這個問題,正是我們很少看到有人單獨使用原型模式的原因所在。