Function 類型有一個屬性叫 prototype,直譯過來就是「原型」。它是一個指針,指向一個對象;這個對象裡的屬性和方法,會被該函數生成的所有實例共享。
function Person(){ ... }
Person.prototype = {
country : 'china',
sayName : function(){ ... }
}
也就是說:
person1 = new Person(); person2 = new Person();
person1 與 person2 都擁有共同的屬性 country 和方法 sayName,因為它們都通過某個指針(__proto__)指向 Person.prototype 所引用的對象。要注意 __proto__ 並不標準,只有 Chrome、Firefox 等瀏覽器自行實現,實際開發中不該使用,它只是理解 prototype 的輔助。

用函數封裝以特定接口創建對象的細節,把重複工作交給函數。
function createPerson(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o;
}
var person1 = createPerson("jiangshui","22","engineer");
工廠模式解決了多個相似對象重複創建的問題,但沒有解決對象識別問題——它只是造了個對象出來,無法區分這個對象究竟基於哪個模板。
自定義構造函數,在其中定義對象的屬性和方法。
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
};
};
var person1 = new Person(...);
與工廠模式的區別在於三點:沒有顯式創建對象、直接把屬性和方法賦給 this、沒有 return 語句。
Person 是 Function 類型的對象,new 之後會產生一個新對象;由於函數中把參數賦值給了 this 指針,傳入的內容就成了新對象的屬性或方法。約定俗成,構造函數首字母大寫。執行過程分四步:
這樣生成的實例默認包含一個 constructor 屬性指向構造函數:
alert(person1.constructor == Person);
因此構造函數模式具備類型標識能力。另外,構造函數本質上就是普通函數,不用 new 直接調用也完全可以,例如執行 Person.sayName() 會彈出 window.name,因為此時函數在 window 作用域下執行,this 指向 window。
它的缺陷是:方法在每個實例上都重新創建了一遍,導致不同實例上的同名函數並不相等。
person1.sayName == person2.sayName; //false
屬性各自獨立是必需的,那正是一個對象有別於另一個對象的地方;但方法邏輯往往完全一致,反覆複製顯然浪費。把函數放到外面再用指針指向它是一種補救:
function Person(name, age){
this.name = name;
this.age = age;
this.sayName = sayName;
}
function sayName(){
alert(this.name);
}
代價是這個函數變成了全局函數,與 Person 的關聯很弱,封裝性蕩然無存。於是該原型模式出場了。
每個函數都有一個 prototype 屬性指向原型對象,函數生成的實例通過 __proto__ 指向該原型。由此可得:prototype 上的屬性和方法是所有實例共享的。
function Person(){ .... }
Person.prototype.name = "jiangshui";
Person.prototype.sayName = function(){ alert(this.name); };
var person1 = new Person();
person1.sayName(); //jiangshui
或者整體覆蓋:
Person.prototype = {
constructor : Person,
name : "jiangshui",
sayName : function(){ alert(this.name); }
};
第二種寫法覆蓋了整个 prototype,所以要手動把 constructor 指回構造函數,否則它會指向 Object。
梳理一下彼此關係:
用 isPrototypeOf() 可以確認對象之間的關係:
Person.prototype.isPrototypeOf(person1);
讀取屬性時的查找規則是:從當前對象開始,沒有則沿指針搜索原型對象,而不會去搜索構造函數。實例可以訪問但不能重寫原型上的值——若實例中設定了同名屬性,查找就在實例這裡結束,達到覆蓋效果。即使把這個屬性設為 null,也只表示實例上存在該屬性,並不會解除覆蓋。要恢復訪問原型,得用 delete 徹底刪除實例屬性。
原型是動態的:對原型對象的任何修改都能立刻反映到實例上,因為實例與原型之間是鬆散鏈接,每次訪問都會重新查詢。
基於這一點,我們也能給原生對象擴充方法:
String.prototype.startsWith = function(text){
return this.indexOf(text) == 0;
};
var msg = "Hello World";
msg.startsWith("Hello");
執行之後,所有字符串變量都獲得了這個方法。但並不推薦這麼做——擴充過多會讓代碼難以維護。更稳妥的做法是繼承原生引用類型,再在自定義類型上擴展。
原型模式的問題在於:原型上的所有屬性和方法被全部實例共享,這對函數非常合適,但對引用類型的屬性就會出麻煩:
function Person(){}
Person.prototype = {
constructor : Person,
friends : ["greg","jack"]
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("tom");
console.log(person2.friends);
person2 的 friends 裡竟然多了一個 tom。給 person1 加好友卻影響到了 person2,這顯然不是我們想要的。
這是最常用的方案:構造函數定義實例屬性,通過參數實現自定義;原型定義方法或需要共享的屬性。既保留自定義能力,又實現共用。
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ["greg","jack"];
}
Person.prototype = {
constructor : Person,
sayName : function(){
alert(this.name);
}
};
var jiangshui = new Person("jiangshui","22","engineer");
這種開發方式主要服務於模塊化與組件化。以常用的彈窗為例:你可以每次複製粘貼彈窗代碼再改改,也可以把彈窗能力抽象封裝成一個組件,之後只需傳參生成實例即可調用。項目越大,這種組織方式的收益越明顯。
JavaScript 中萬物皆對象,但對象大致可分兩類:普通對象(Object)和函數對象(Function)。一般說來,通過 new Function 產生的對象是函數對象,其餘都是普通對象。
function f1(){ /* todo */ }
var f2 = function(){ /* todo */ };
var f3 = new Function('x','console.log(x)');
var o1 = {};
var o2 = new Object();
var o3 = new f1();
console.log( typeof f1, //function
typeof f2, //function
typeof f3, //function
typeof o1, //object
typeof o2, //object
typeof o3 //object
);
f1 是函數聲明,最常見的定義方式;f2 是把匿名函數賦值給變量,屬於函數表達式;f3 不常見,但也確實是一個函數對象。Function 是 JS 自帶的對象,f1、f2 在創建時由 JS 自動以 new Function() 的方式構建,因此這三個都是函數對象。
創建對象的方式有兩種:對象字面量和 new 表達式,o1 與 o2 恰好對應。重點看 o3——若按 Java、C# 的思路,會覺得 o3 是 f1 的實例對象、和 f1 同類型,其實不然。判斷很簡單:o3 不是通過 new Function 產生的,既然不是函數對象,那就是普通對象。
接著看原型與原型鏈。每當創建一個函數對象 f1,它都會內置一些屬性,其中包括 prototype 和 __proto__。prototype 即原型對象,記錄著 f1 的一些屬性和方法。
注意 prototype 對 f1 自身是不可見的,f1 不會查找其中的屬性和方法:
function f(){}
f.prototype.foo = "abc";
console.log(f.foo); //undefined
那 prototype 有什麼用?主要作用就是繼承——原型中定義的屬性和方法是留給「後代」用的,子類完全可以訪問。
這時 __proto__ 登場了。它藏得很深,平時幾乎看不見,但在普通對象和函數對象中都存在,作用是保存父類的 prototype 對象。JS 在用 new 表達式創建對象時,通常會把父類的 prototype 賦值給新對象的 __proto__,一代代傳承下去。
function f(){}
f.prototype.foo = "abc";
var obj = new f();
console.log(obj.foo); //abc
obj 的 __proto__ 保存的是 f 的 prototype。那 f.prototype 的 __proto__ 裡又是什麼?

如圖所示,f.prototype 的 __proto__ 保存的是 Object.prototype;Object.prototype 也有 __proto__,其值為 null,代表原型鏈到此終結。

有了這條原型鏈,執行 obj.foo 時,obj 會先查找自身(但不會查找自己的 prototype),找不到就沿著原型鏈依次向上,最終在 f.prototype 上命中並執行。