用過 JavaScript 的人大概都聽說過 prototype,但它到底是什麼,卻讓不少初學者摸不著頭腦——只知道函數有個 prototype 屬性、能掛方法供實例訪問,再深一層就模糊了。本文就來徹底揭開它的面紗。
每個函數都有一個 prototype 屬性,它指向一個被稱為原型物件的引用。原型物件包含供函數實例共享的方法和屬性。也就是說,當函數作為構造函數(用 new 調用)時,新創建的物件會從原型物件繼承屬性和方法。與傳統面向物件語言不同,JavaScript 的繼承機制基於原型,而非 class 類。
在函數內定義、不對外暴露的變數和函數,外部無法訪問,成為私有成員:
function Obj(){
var a = 0; // 私有變數
var fn = function(){}; // 私有函數
}即使創建實例,也無法訪問這些私有成員:
var o = new Obj(); console.log(o.a); // undefined console.log(o.fn); // undefined
通過「.」為函數添加的屬性和函數,函數本身可訪問,但實例訪問不到,稱為靜態成員:
function Obj(){}
Obj.a = 0; // 靜態變數
Obj.fn = function(){}; // 靜態函數
console.log(Obj.a); // 0
console.log(typeof Obj.fn);// function
var o = new Obj();
console.log(o.a); // undefined
console.log(typeof o.fn); // undefined用 this 定義的屬性和方法,實例化後可訪問:
function Obj(){
this.a = []; // 實例變數
this.fn = function(){}; // 實例方法
}
var o = new Obj();
console.log(typeof o.a); // object
console.log(typeof o.fn); // function但這會帶來一個問題:
function Obj(){
this.a = [];
this.fn = function(){};
}
var o1 = new Obj();
o1.a.push(1);
o1.fn = {};
var o2 = new Obj();
console.log(o2.a); // [],未受 o1 影響
console.log(typeof o2.fn);// function由於陣列和函數都是引用型別,o1 和 o2 中的同名屬性其實是各自獨立的一份複製。對屬性來說無所謂,但對方法來說就很浪費——每個實例都要複製一份完全相同的方法。如果有上千個實例,就意味着上千份方法副本。prototype 正是為了解決這個問題而生。
JavaScript 中萬物皆物件,但物件分普通物件和函數物件,Object 與 Function 是 JS 自帶的函數物件:
function f1(){};
var f2 = function(){};
var f3 = new Function('str', 'console.log(str)');
var o1 = {};
var o2 = new Object();
var o3 = new f1();
console.log(typeof f1); // function
console.log(typeof o1); // object區分很簡單:凡是通過 new Function() 創建的物件都是函數物件,其餘都是普通物件。f1、f2 歸根結底也是通過 new Function() 創建的。
每當定義一個函數物件時,它都會有一個 prototype 屬性(普通物件沒有 prototype,但有 __proto__)。原型物件其實就是一個普通物件(Function.prototype 除外,它是特殊的函數物件,且沒有自己的 prototype):
function f1(){};
console.log(f1.prototype); // f1 {}
console.log(typeof f1.prototype); // Object
console.log(typeof Function.prototype); // Function,這個特殊
console.log(typeof Object.prototype); // Object
console.log(typeof Function.prototype.prototype); // undefined從 console.log(f1.prototype) 的輸出可以看出,f1.prototype 就是 f1 的一個實例物件。基本過程相當於:
var temp = new f1(); f1.prototype = temp;
原型物件的主要作用是實現繼承:
var person = function(name){ this.name = name };
person.prototype.getName = function(){ return this.name; };
var xpg = new person('xiaopingguo');
xpg.getName(); // xiaopingguo給 person.prototype 設置方法後,person 的實例就繼承了這個方法。
再深入一點:只要創建了一個新函數,就會為它創建一個 prototype 屬性(同時也是物件),預設情況下 prototype 會獲得一個 constructor 屬性,指向 prototype 所在的函數。
function Person(){ }
Person 自動獲得 prototype 屬性,prototype 又自動獲得 constructor 屬性,指向 Person 本身。當用構造函數創建實例時,實例內部含有一個內部指針(多數瀏覽器命名為 __proto__)指向構造函數的 prototype。這個連接存在於實例與構造函數的 prototype 之間,而非實例與構造函數之間。
function Person(name){ this.name = name; }
Person.prototype.printName = function(){ alert(this.name); };
var person1 = new Person('Byron');
var person2 = new Person('Frank');
person1 中有 name 屬性,同時自動生成 __proto__ 指向 Person 的 prototype,因而能訪問到 printName 方法:

測試驗證 prototype 上的屬性、方法確實是共享的:
function Person(name){ this.name = name; }
Person.prototype.share = [];
Person.prototype.printName = function(){ alert(this.name); };
var person1 = new Person('Byron');
var person2 = new Person('Frank');
person1.share.push(1);
person2.share.push(2);
console.log(person2.share); // [1,2]當讀取某個屬性時,都會執行一次搜索:先從實例本身找起,找不到再查 prototype,接著遞歸 prototype 的 prototype,直到找到為止;若一直到 Object 都沒有,則返回 undefined。若實例中定義了與 prototype 同名的屬性,就會覆蓋原型上的屬性——這就是原型鏈。
function Person(name){ this.name = name; }
Person.prototype.share = [];
var person = new Person('Byron');
person.share = 0;
console.log(person.share); // 0,而非原型中的 []JS 在創建物件時,都有一個內建屬性 __proto__,用於指向創建它的函數物件的原型 prototype:
console.log(xpg.__proto__ === person.prototype); // true
person.prototype 也有 __proto__,指向創建它的函數物件(Object)的 prototype:
console.log(person.prototype.__proto__ === Object.prototype); // true
而 Object.prototype 的 __proto__ 比較特殊,為 null:
console.log(Object.prototype.__proto__); // null
這條由 __proto__ 串起來、直到 Object.prototype.__proto__ 為 null 的鏈,就是原型鏈:

原型鏈中的屬性查找:查找屬性時,JavaScript 會沿原型鏈向上遍歷,直到找到目標屬性;若一直找到 Object.prototype 仍未找到,就返回 undefined。
function foo() {
this.add = function (x, y) { return x + y; }
}
foo.prototype.add = function (x, y) { return x + y + 10; };
Object.prototype.subtract = function (x, y) { return x - y; };
var f = new foo();
alert(f.add(1, 2)); // 3,而非 13(實例屬性優先)
alert(f.subtract(1, 2)); // -1(沿原型鏈向上找到)由此可見,屬性查找先看自身,再查原型,然後一路向上直到 Object 的原型。需要注意的是,我們可以給原型賦值任意類型的物件,但不能賦值原子型別的值:
function Foo() {}
Foo.prototype = 1; // 無效實例通過構造函數創建,一經創建就具備 constructor 屬性(指向構造函數)和 __proto__ 屬性(指向原型物件)。構造函數有一個 prototype 屬性,指向它的原型物件;原型物件內部也有 constructor 指針指回構造函數;實例則可訪問原型上的屬性和方法。
<script type="text/javascript">
function Animal(name) { this.name = name; }
Animal.prototype.behavior = function() {
alert("this is a " + this.name);
};
var Dog = new Animal("dog");
var Cat = new Animal("cat");
Dog.behavior(); // this is a dog
Cat.behavior(); // this is a cat
alert(Dog.behavior == Cat.behavior); // true
</script>方式一:給 prototype 賦值物件字面量。
var Calculator = function (decimalDigits, tax) {
this.decimalDigits = decimalDigits;
this.tax = tax;
};
Calculator.prototype = {
add: function (x, y) { return x + y; },
subtract: function (x, y) { return x - y; }
};
// alert((new Calculator()).add(1, 3));方式二:用立即執行的函數表達式賦值,可封裝私有函數,達到 public/private 的效果。
Calculator.prototype = function () {
add = function (x, y) { return x + y; };
subtract = function (x, y) { return x - y; };
return { add: add, subtract: subtract }
}();分步聲明:也可以逐個設置原型屬性,避免一次性覆寫。
var BaseCalculator = function () { this.decimalDigits = 2; };
BaseCalculator.prototype.add = function (x, y) { return x + y; };
BaseCalculator.prototype.subtract = function (x, y) { return x - y; };重寫原型:使用第三方庫時,往往需要覆寫其原型方法。此時重寫的代碼必須放在最後,才能覆蓋前面的定義。
function Calculator.prototype.add = function (x, y) {
return x + y + this.tax;
};
var calc = new Calculator();
alert(calc.add(1, 1));hasOwnProperty 是 Object.prototype 上的方法,是 JavaScript 中唯一一個只處理物件自身屬性、不查找原型鏈的函數:
Object.prototype.bar = 1;
var foo = { goo: undefined };
foo.bar; // 1
'bar' in foo; // true
foo.hasOwnProperty('bar'); // false
foo.hasOwnProperty('goo'); // true但有個坑:JavaScript 不會保護 hasOwnProperty 被非法佔用,若物件恰好有同名屬性,就要用外部函數調用:
var foo = { hasOwnProperty: function() { return false; }, bar: 'Here be dragons' };
foo.hasOwnProperty('bar'); // 總是返回 false
{}.hasOwnProperty.call(foo, 'bar'); // true在使用 for..in 遍歷物件時,推薦總是使用 hasOwnProperty,以避免原型擴展帶來的干擾:
Object.prototype.bar = 1;
var foo = { moo: 2 };
for (var i in foo) {
if (foo.hasOwnProperty(i)) {
console.log(i); // 只輸出 moo
}
}總結:推薦使用 hasOwnProperty,不要對運行環境做任何假設,永遠不要假設原生物件沒有被擴展過。
__proto__(IE 不支持)是實例指向原型物件的一個指針,通過它可以訪問原型裡的屬性和方法。JavaScript 物件實例本質上由一系列屬性組成,其中有一個內部的、不可見的特殊屬性 __proto__,其值指向該實例的原型,一個實例只擁有一個唯一的原型。
function Box(){}
Box.prototype.name = "trigkit4";
Box.prototype.age = "21";
Box.prototype.run = function(){ return this.name + this.age + 'studying'; }
var box1 = new Box();
alert(box1.constructor); // 構造屬性,可獲取構造函數本身__proto__ 與 prototype 的區別:prototype 是函數物件專有的屬性;__proto__ 是普通物件的隱式屬性,在 new 時指向 prototype 所指的物件。__proto__ 屬於某個實體物件,prototype 屬於構造函數,且 __proto__ 只能用於學習或調試環境。
原型模式的執行流程:
function Box(){}
Box.prototype.name = "trigkit4";
Box.prototype.run = function(){ return this.name + this.age + 'studying'; }
var box1 = new Box();
alert(box1.name); // trigkit4,原型裡的值
box1.name = "Lee"; // 就近原則,改的是實例自身
alert(box1.name); // Lee
var box2 = new Box();
alert(box2.name); // trigkit4,未受 box1 影響若構造函數內部也定義了 name,則實例優先取自身的值:
function Box(){ this.name = "Bill"; }
Box.prototype.name = "trigkit4";
Box.prototype.age = "21";
var box1 = new Box();
alert(box1.name); // Bill,實例自身的屬性優先最後整理一下核心要點:
function Person(){};
Person.prototype.name = "trigkit4";
Person.prototype.say = function(){ alert("Hi"); }
var p1 = new Person();
var p2 = new Person();
console.log(p1.prototype); // undefined
console.log(Person.prototype); // Person 的原型物件
console.log(Person.prototype.constructor); // 指回構造函數
console.log(p1.__proto__); // 指向 prototype 的指針
p1.say(); // 實例可訪問原型上的方法以上就是本文的全部內容,希望對你理解 JavaScript 原型機制有所幫助。