在 JavaScript 的世界裡,原型(prototype)與原型鏈(prototype chain)堪稱面試與日常開發中的必考知識點。理解它們,等於掌握了這門語言物件導向機制的鑰匙。本文將從最基礎的概念出發,層層遞進地帶你走進原型的世界。
可以這麼理解:JavaScript 中幾乎每個物件都關聯著一個 prototype 屬性,它保存著對另一個物件的引用,而被引用的這個物件,往往充當著當前物件的「父級」角色。
A.prototype = new B();
需要特別提醒的是,理解 prototype 時不要把它和繼承混為一談。A 的 prototype 是 B 的一個實例,你可以把它想象成 A 把 B 的屬性與方法完整地「複製」了一份過來,於是 A 就能使用 B 的能力。這裡強調的是複製,而非繼承。甚至可以出現 A 的 prototype 是 B 的實例、而 B 的 prototype 又是 A 的實例這種情況。
在一個函數內部定義的變量和函數,如果不對外暴露任何接口,那麼外部是無法訪問的,它們就成為了這個函數的私有成員。
<script type="text/javascript">
function Box(){
var color = "blue"; // 私有變量
var fn = function(){ // 私有函數
}
}
var obj = new Box();
alert(obj.color); // undefined
alert(obj.fn); // undefined
</script>
可以看到,在 Box 外部根本拿不到 color 和 fn,它們被牢牢地封裝了起來。
定義好一個函數後,通過點號「.」為它掛上的屬性和函數,函數本身依然可以訪問,但它的實例卻無法訪問。這樣的成員被稱為靜態變量與靜態函數。
<script type="text/javascript">
function Obj(){};
Obj.num = 72; // 靜態變量
Obj.fn = function(){ // 靜態函數
}
alert(Obj.num); // 72
alert(typeof Obj.fn); // function
var t = new Obj();
alert(t.name); // undefined
alert(typeof t.fn); // undefined
</script>
在物件導向編程中,我們往往希望在定義物件的同時就定義好屬性和方法,實例化之後即可訪問,JavaScript 同樣能做到。
<script type="text/javascript">
function Box(){
this.a = []; // 實例變量
this.fn = function(){ // 實例方法
}
}
console.log(typeof Box.a); // undefined
console.log(typeof Box.fn); // undefined
var box = new Box();
console.log(typeof box.a); // object
console.log(typeof box.fn); // function
</script>
為實例變量和方法新增屬性後,我們會發現一個有趣的現象:
<script type="text/javascript">
function Box(){
this.a = [];
this.fn = function(){
}
}
var box1 = new Box();
box1.a.push(1);
box1.fn = {};
console.log(box1.a); // [1]
console.log(typeof box1.fn);// object
var box2 = new Box();
console.log(box2.a); // []
console.log(typeof box2.fn);// function
</script>
box1 改動了 a 和 fn,box2 卻不受影響。由於數組和函數都是引用類型的物件,這說明 box1 與 box2 中同名的屬性和方法並非同一個引用,而是各自持有的一份複製。
對屬性而言這還無傷大雅,但對方法來說問題就大了:每個方法本質上都在做同樣的事,卻被複製了無數份。如果一個構造函數有成千上萬個實例方法,那麼每個實例都要背著上千份的方法副本,這顯然極不科學。於是,prototype 應運而生。
我們創建的每個函數都有一個 prototype 屬性,它是一個指針,指向一個物件。這個物件的用途是容納所有該類型實例都能共享的屬性和方法。換句話說,prototype 就是通過構造函數創建出的實例所共享的那個原型物件。
使用原型的最大好處,就在於讓物件實例共享其中的屬性和方法。也就是說,我們不必把這些資訊塞進構造函數裡,而是直接掛到原型上。構造函數的老問題——每個方法都要在每個實例裡創建一遍——就此迎刃而解。
在 JavaScript 中,值可以分為原始值和物件值兩大類。每個物件都有一個內部屬性 prototype,我們通常稱之為原型。原型的值可以是一個物件,也可以是 null;如果是一個物件,那麼這個物件同樣擁有自己的原型。如此一層層向上,就形成了一條線性的鏈條,這便是原型鏈。
函數可以作為構造函數使用。只有函數才具備可訪問的 prototype 屬性,而物件實例並沒有這個屬性,它只有一個內部、通常不可直接訪問的 __proto__ 屬性。__proto__ 是物件指向其相關原型的一條神秘鏈接。按照標準,__proto__ 本是不對外公開的私有屬性,但 Firefox 的引擎將它暴露出來,讓我們能夠讀取與設置。
<script type="text/javascript">
var Browser = function(){};
Browser.prototype.run = function(){
alert("I'm Gecko, a kernel of firefox");
}
var Bro = new Browser();
Bro.run();
</script>
當我們調用 Bro.run() 時,由於 Bro 自身並沒有這個方法,於是它會沿著 __proto__ 去 Browser.prototype 上查找,最終執行到 run()。(本系列中首字母大寫的函數都代表構造函數,用以區分普通函數。)
當你使用構造函數創建實例時,實例內部會包含一個指針(__proto__)指向構造函數的 prototype。這個連接存在於實例與構造函數的 prototype 之間,而不是實例與構造函數本身之間。
<script type="text/javascript">
function Person(name){ // 構造函數
this.name = name;
}
Person.prototype.printName = function(){ // 原型物件
alert(this.name);
}
var person1 = new Person('Byron'); // 實例化物件
console.log(person1.__proto__); // Person
console.log(person1.constructor); // 自己試試看
console.log(Person.prototype); // 指向原型物件
var person2 = new Person('Frank');
</script>
Person 的實例 person1 包含了 name 屬性,同時自動生成一個 __proto__ 屬性,指向 Person 的 prototype,因此可以訪問到原型裡定義的 printName 方法:

每個 JavaScript 函數都有 prototype 屬性,它引用一個物件,也就是原型物件。原型物件初始化時是空的,我們可以在裡面自定義任意屬性和方法,這些成員都將被該構造函數創建的物件所繼承。
那麼,三者之間究竟有何關聯?理清下面幾點就清晰了:
實例由構造函數創建,一經創造便擁有 constructor 屬性(指向構造函數)和 __proto__ 屬性(指向原型物件);構造函數中有一個 prototype 屬性,是指向原型物件的指針;原型物件內部也有一個指針(constructor 屬性)指回構造函數,即 Person.prototype.constructor = Person; 而實例可以訪問原型物件上定義的屬性和方法。
再舉個例子:
<script type="text/javascript">
function Animal(name){ // 構造函數
this.name = name; // 設置物件屬性
}
Animal.prototype.behavior = function(){ // 為 prototype 添加 behavior 方法
alert("this is a " + this.name);
}
var Dog = new Animal("dog"); // 創建 Dog 物件
var Cat = new Animal("cat"); // 創建 Cat 物件
Dog.behavior();
Cat.behavior(); // 輸出 "this is a cat"
alert(Dog.behavior == Cat.behavior); // true
</script>
從運行結果可以看出,構造函數 prototype 上定義的方法能被物件直接調用,而且代碼是共享的。(試著把 Animal.prototype.behavior 中的 prototype 去掉,看看還能不能運行。)在這裡,prototype 指向 Animal 物件。
再看一個數組物件的例子。當我們創建 array1 這個物件時,它在 JavaScript 引擎中的物件模型如下:
var array1 = [1,2,3];

array1 有一個 length 屬性,值為 3,但我們可以通過下面的方式為它增加元素:
array1.push(4);
push 這個方法來自 array1 的 __proto__ 成員所指向物件的成員方法(Array.prototype.push())。正是因為所有通過 [] 創建的數組物件都包含一個指向同一個物件(Array.prototype)的 __proto__,這些數組才能共享 push、reverse 等方法。
function Base() {
this.id = "base"
}

var obj = new Base();

那麼 new 操作符到底做了什麼?其實很簡單,就三件事:
var obj = {};
obj.__proto__ = Base.prototype;
Base.call(obj);
所謂原型鏈,是指當你從一個物件上取屬性或方法時,如果該物件自身沒有,就會去它關聯的 prototype 物件上尋找;若還沒有,就繼續沿著前輩的 prototype 向上查找,如此類推,直到 Prototype……Prototype 為 undefined(Object 的 Prototype 就是 undefined)為止,這條查找路徑便構成了「原型鏈」。
<script type="text/javascript">
function Shape(){
this.name = "shape";
this.toString = function(){
return this.name;
}
}
function TwoShape(){
this.name = "2 shape";
}
function Triangle(side,height){
this.name = "Triangle";
this.side = side;
this.height = height;
this.getArea = function(){
return this.side*this.height/2;
}
}
TwoShape.prototype = new Shape();
Triangle.prototype = new TwoShape();
</script>
這裡用構造器 Shape() 新建了一個實例,再用它去覆蓋該物件的原型。為保證 constructor 指向正確,通常還需補上:
<script type="text/javascript">
function Shape(){
this.name = "shape";
this.toString = function(){
return this.name;
}
}
function TwoShape(){
this.name = "2 shape";
}
function Triangle(side,height){
this.name = "Triangle";
this.side = side;
this.height = height;
this.getArea = function(){
return this.side*this.height/2;
}
}
TwoShape.prototype = new Shape();
Triangle.prototype = new TwoShape();
TwoShape.prototype.constructor = TwoShape;
Triangle.prototype.constructor = Triangle;
var my = new Triangle(5,10);
my.getArea();
my.toString(); // Triangle
my.constructor; // Triangle(side,height)
</script>
在原型鏈的末端,就是 Object 構造函數 prototype 屬性所指的那個原型物件。它是所有物件的祖先,實現了 toString 等所有物件天生就該具備的方法。Function、Boolean、String、Date、RegExp 等內置構造函數的 prototype 都從這個「老祖宗」傳承而來,同時又各自定義了自己的屬性和方法,於是它們的子孫便表現出各宗族不同的特徵。
在 ECMAScript 中,實現繼承的方式就是依靠原型鏈。
<script type="text/javascript">
function Box(){ // 被繼承的函數叫超類型(父類、基類)
this.name = "Jack";
}
function Tree(){ // 繼承的函數叫子類型(子類、派生類)
this.age = 300;
}
Tree.prototype = new Box(); // Tree 繼承了 Box,通過原型形成鏈條
var tree = new Tree();
alert(tree.name); // 彈出 Jack
</script>
原型鏈雖然強大,但也存在問題。最主要的一個問題來自包含引用類型值型的原型屬性:包含引用類型的原型屬性會被所有實例共享,這也正是為什麼我們要在構造函數中、而不是在原型物件中定義屬性的原因。通過原型實現繼承時,原型實際上會變成另一個類型的實例,於是原本屬於實例的屬性也就搖身一變成了原型的屬性。
此外,創建子類型實例時,無法向超類型的構造函數傳遞參數——準確地說,是沒有辦法在不影響所有物件實例的前提下給超類型構造函數傳參。再加上原型中包含引用類型值帶來的困擾,實踐中很少有人單獨使用原型鏈。
再看個例子:
<script type="text/javascript">
function Person(name){
this.name = name; // 設置物件屬性
};
Person.prototype.company = "Microsoft"; // 設置原型的屬性
Person.prototype.SayHello = function(){ // 原型的方法
alert("Hello, I'm " + this.name + " of " + this.company);
};
var BillGates = new Person("BillGates");
BillGates.SayHello(); // "Hello, I'm BillGates of Microsoft"
var Jobs = new Person("Jobs");
Jobs.company = "Apple"; // 設置自己的 company,掩蓋了原型的屬性
Jobs.SayHello = function(){
alert("Hi, " + this.name + " like " + this.company);
};
Jobs.SayHello(); // "Hi, Jobs like Apple"
BillGates.SayHello(); // Jobs 的覆蓋不影響原型,BillGates 照舊輸出
</script>
再看一個原型鏈的例子:
<script type="text/javascript">
function Year(){
this.value = 21;
}
Year.prototype = {
method:function(){
}
};
function Hi(){
};
Hi.prototype = new Year(); // 設置 Hi 的 prototype 為 Year 的實例
Hi.prototype.year = 'Hello World';
Hi.prototype.constructor = Hi;
var test = new Hi(); // 創建 Hi 的新實例
// 原型鏈
test [Hi 的實例]
Hi.prototype [Year 的實例]
{year:'Hello World'}
Year.prototype
{method:……};
object.prototype
{toString:...};
</script>
從這個例子可以看到,test 物件從 Hi.prototype 和 Year.prototype 中繼承下來,因此它既能訪問 Year 的原型方法 method,也能訪問實例屬性 value。
__proto__ 屬性(IE 瀏覽器不支持)是指向原型物件的一個指針,其作用是指向構造函數的 prototype,透過它我們就能訪問原型裡的屬性和方法。
JavaScript 中的物件實例本質上由一系列屬性組成,其中有一個內部不可見的特殊屬性——__proto__,它的值指向該實例的原型,而一個實例只擁有唯一一個原型。
<script type="text/javascript">
function Box(){ // 大寫,代表構造函數
Box.prototype.name = "trigkit4"; // 原型屬性
Box.prototype.age = "21";
Box.prototype.run = function(){ // 原型方法
return this.name + this.age + 'studying';
}
}
var box1 = new Box();
var box2 = new Box();
alert(box1.constructor); // 構造屬性,可獲取構造函數本身
</script>
prototype 是 function 物件專有的屬性;__proto__ 是普通物件的隱式屬性,在 new 的時候會指向 prototype 所指的物件。__proto__ 屬於某個實體物件,而 prototype 則屬於構造函數。__proto__ 僅建議在學習或調試環境下使用。
1. 先查找構造函數實例裡的屬性或方法,如果有,立即返回;
2. 如果實例裡沒有,就去它的原型物件裡找,如果有,立即返回。
當實例自身沒有該屬性時,會讀取原型裡的值;一旦在實例上重新賦值,就遵循「就近原則」使用實例自己的值,而這不會影響原型,也不會影響其他實例:
<script type="text/javascript">
function Box(){
this.name = "Bill";
}
Box.prototype.name = "trigkit4"; // 原型屬性
Box.prototype.age = "21";
Box.prototype.run = function(){
return this.name + this.age + 'studying';
}
var box1 = new Box();
alert(box1.name); // Bill(實例屬性優先)
box1.name = "Lee";
alert(box1.name); // Lee(就近原則)
</script>
工廠模式:
function createObject(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
return obj;
}
工廠模式解決了物件大量重複實例化的問題,卻留下了一個遺憾:根本無法判斷這些物件究竟是哪個類型的實例。而使用構造函數,既解決了重複實例化,又解決了物件識別的問題。
構造函數方式與工廠模式的不同之處在於:
1. 構造函數方法沒有顯式地創建物件(new Object());
2. 直接將屬性和方法賦值給 this 物件;
3. 沒有 return 語句。
當你使用構造函數並 new 它時,後台其實執行了 new Object(),函數體內的 this 就代表 new 出來的那個物件。
最後幾點值得記住:
1. 判斷屬性是在實例裡還是在原型裡,可以用 hasOwnProperty() 函數;
2. 字面量創建的方式,其 constructor 會指向 Object,而構造函數創建的方式則相反。之所以指向 Object,是因為 Box.prototype = {}; 這種寫法其實就是新建了一個物件;
3. 如果是實例方法,不同實例化的方法地址各不相同,是唯一的;
4. 如果是原型方法,那麼它們的地址是共享的。