在函數內部定義的變數與函數,若不對外提供介面,外部就無法存取,這就是私有成員。
<script type="text/javascript">
function Test(){
var color = "blue"; // 私有變數
var fn = function() // 私有函數
{
}
}
</script>
因此在 Test 外部取不到 color 與 fn:
var obj = new Test();
alert(obj.color); // 彈出 undefined
alert(obj.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>
物件導向開發中,除了工具函數,我們通常希望在定義時就一併宣告一組可在實例上存取的屬性與方法:
<script type="text/javascript">
function Obj(){
this.a = []; // 實例變數
this.fn = function(){ // 實例方法
}
}
console.log(typeof Obj.a); // undefined
console.log(typeof Obj.fn); // undefined
var o = new Obj();
console.log(typeof o.a); // object
console.log(typeof o.fn); // function
</script>
實例建立後,也可以再為它加上新的成員:
<script type="text/javascript">
function Obj(){
this.a = []; // 實例變數
this.fn = function(){ // 實例方法
}
}
var o1 = new Obj();
o1.a.push(1);
o1.fn = {};
console.log(o1.a); // [1]
console.log(typeof o1.fn); // object
var o2 = new Obj();
console.log(o2.a); // []
console.log(typeof o2.fn); // function
</script>
在 o1 中改動了 a 與 fn,o2 卻完全不受影響。雖然陣列與函數都是「物件」也就是參考型別,但這裡說明 o1 與 o2 的同名成員並非同一個參考,而是各自持有建構時複製出來的一份。
對屬性來說這沒什麼問題,但對方法來說就很浪費了——每個方法的實作完全相同,卻要在每個實例上各存一份。若一個建構函數有上千個實例、每個實例有幾十個方法,記憶體的浪費相當可觀。prototype 就是為了解決這個問題而存在的。
我們建立的每個函數都有一個 prototype 屬性,它是一個指標,指向一個物件。這個物件的用途是保存「可由該型別的所有實例共享」的屬性與方法。因此 prototype 就是透過呼叫建構函數所建立出的實例的原型物件。
使用原型的好處是讓所有實例共享同一份屬性與方法,不必在建構函數裡重複定義。在 JavaScript 中,值分成原始值與物件值兩類,每個物件都有一個內部屬性 prototype(通常稱為原型),其值可以是物件或 null。若它是物件,該物件也有自己的原型,這樣就形成一條線性的鏈,稱為原型鏈。
函數可以作為建構函數使用。只有函數才有可存取的 prototype 屬性,物件實例並沒有這個屬性,只有一個內部、不可直接存取的 __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,於是執行了該方法。(慣例上首字母大寫的都代表建構函數,用以區別普通函數)
關鍵在於:用 new 建立實例時,實例內部會產生一個指標指向建構函數的 prototype。這個連結存在於實例與建構函數的 prototype 之間,而不是實例與建構函數之間。
<script type="text/javascript">
function Person(name){
this.name = name;
}
Person.prototype.printName = function(){
alert(this.name);
}
var person1 = new Person('Byron');
var person2 = new Person('Frank');
</script>
person1 含有 name 屬性,同時自動產生一個 __proto__ 指向 Person 的 prototype,因此可以存取其中定義的 printName。

再看一個例子:
<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(); // 通過 Dog 物件直接呼叫 behavior 方法
Cat.behavior(); // output "this is a cat"
alert(Dog.behavior == Cat.behavior); // output true;
</script>
可以從結果看出,定義在 prototype 上的方法確實能透過物件直接呼叫,而且程式碼是共享的——Dog.behavior == Cat.behavior 為 true,說明兩者指向同一個函數物件。(可以試著把 Animal.prototype.behavior 中的 prototype 去掉,看看還能不能執行。)
建立 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、再以該物件作為 this 呼叫建構函數。理解這三步,就能解釋絕大多數與 new 相關的現象。
當從一個物件取值或呼叫方法時,若該物件自身沒有這樣的成員,就會去它關聯的 prototype 物件尋找;若 prototype 沒有,就繼續往上一層的 prototype 找,依此類推,直到 Object.prototype(其原型為 null)為止,這條查找路徑就是「原型鏈」。
<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() 建立一個實體,然後用它覆蓋該物件的原型,从而形成繼承關係。
<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>
補上 constructor 是因為重新指定 prototype 會連原本的 constructor 一起覆蓋掉,若不修回來,my.constructor 會指向錯誤的函數。
原型鏈的終點是 Object 建構函數 prototype 所指向的物件。這個物件是所有物件的祖先,實作了 toString 等所有物件天生具備的方法。Function、Boolean、String、Date、RegExp 等內在建構函數的 prototype 都從這裡傳承下來,但各自又定義了自己的屬性與方法,因此它們的「子孫」會表現出各自的特徵。ECMAScript 中,繼承正是依靠原型鏈實作。
<script type="text/javascript">
function Box(){ // 被繼承的函數叫做超類型(父類、基底類)
this.name = "Jack";
}
function Tree(){ // 繼承的函數叫做子類型(子類、派生類)
this.age = 300;
}
// 通過原型鏈繼承,賦值給子類型的原型屬性
// new Box() 會將 Box 構造裡的資訊和原型裡的資訊都交給 Tree
Tree.prototype = new Box(); // Tree 繼承了 Box,通過原型形成鏈條
var tree = new Tree();
alert(tree.name); // 彈出 Jack
</script>
原型鏈的問題:最主要的問題來自包含參考型別值的原型屬性——它會被所有實例共享。這也正是「屬性該定義在建構函數中而非原型上」的原因。透過原型實作繼承時,原型實際上變成了另一個型別的實例,於是原本屬於實例的屬性也變成了原型的屬性,多個子實例會互相干擾。
另外,建立子型別實例時無法向超型別的建構函數傳遞參數——或者說,沒有辦法在不影響所有實例的前提下傳參。加上上述參考型別的問題,實務上很少單獨使用原型鏈,而會搭配「 constructor 借用 + 原型鏈」或 ES6 的 class 語法。
<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"); // 建立 person 物件
BillGates.SayHello(); // 繼承了原型的內容,輸出 "Hello, I'm BillGates of Microsoft"
var Jobs = new Person("Jobs");
Jobs.company = "Apple"; // 設定自己的 company 屬性,掩蓋了原型的 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 屬性為 Year 的實例物件
Hi.prototype = new 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 不支援)是實例指向原型物件的一個指標,透過它能存取原型裡的屬性與方法。
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__ 只適合在學習或除錯環境下使用,正式程式碼應改用 Object.getPrototypeOf()。屬性查找的執行流程:
<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();
alert(box1.name); // trigkit4,原型裡的值
box1.name = "Lee";
alert(box1.name); // Lee,就近原則
var box2 = new Box();
alert(box2.name); // trigkit4,原型的值,沒有被 box1 修改
</script>
這裡的「就近原則」很重要:為實例設定屬性時,並不會覆寫原型上的值,而是在實例上新建一個同名屬性來遮蔽它。這也是為什麼原型上的物件型別屬性會被所有實例共享,進而互相影響。
<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>
當建構函數裡設定了 this.name,實例就擁有自己的 name,查找時會在第一步就命中,永遠拿不到原型上的 "trigkit4"。這說明屬性該放哪裡取決於它是否應該被共享:每個實例各自擁有的資料放建構函數,所有實例共用的方法放 prototype。