
原型是 JavaScript 最容易被誤解、卻也最關鍵的機制。理解它之後,new 做了什麼、屬性怎麼被「找到」、繼承怎麼發生,都會變得很自然。
定義一個物件 obj,它的原型是 obj.__proto__。用 ES5 的 Object.getPrototypeOf() 可以查詢,而判斷它是否等於 Object.prototype 會回傳 true——這證明原型確實存在,而且所有物件的原型最終都指向 Object.prototype。
再看函數:任何函數都有一個 prototype 屬性(函數的原型物件),我們可以在上面掛任何屬性,用 new 產生的實例便能共享這些屬性。
function foo() {}
foo.prototype.z = 3;
var obj = new foo();
obj.x = 1;
obj.y = 2;
obj.x // 1
obj.y // 2
obj.z // 3 ← 來自原型鏈
typeof obj.toString // "function"
obj.valueOf(); // foo {x: 1, y: 2, z: 3}
obj.hasOwnProperty('z'); // false ← z 不是 obj 自己的屬性

這段程式說明了原型鏈的全貌:obj.__proto__ 指向 foo.prototype,foo.prototype.__proto__ 指向 Object.prototype,再往上就是 null——鏈的終點。
hasOwnProperty('z') 回傳 false,因為 z 不在 obj 身上;但 obj.z 依然取到 3,因為查找沿著原型鏈往上找到了 foo.prototype。同理,toString 與 valueOf 來自 Object.prototype,所以每個物件都有這兩個方法。
唯一你得小心的是這種刻意切斷原型鏈的寫法:
var obj2 = Object.create(null); obj2.valueOf(); // TypeError:沒有這個方法
Object.create(參數) 會建立一個空物件,並把它的原型設為傳入的參數。傳 null 就是完全不繼承,這種物件常被當成「純字典」使用,因為它不會被 Object.prototype 上的屬性污染。
// 父類
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.hi = function () {
console.log('Hi, my name is ' + this.name + ', my age is ' + this.age);
};
Person.prototype.LEGS_NUM = 2;
Person.prototype.ARMS_NUM = 2;
Person.prototype.walk = function () {
console.log(this.name + ' is walking !');
};
// 子類
function Student(name, age, classNum) {
Person.call(this, name, age); // 借用父類建構子,初始化 name 與 age
this.classNum = classNum;
}
// 建立空物件作為子類原型,原型指向父類原型
Student.prototype = Object.create(Person.prototype);
// 修正 constructor 指向
Student.prototype.constructor = Student;
Student.prototype.hi = function () {
console.log('Hi, my name is ' + this.name + ', my age is '
+ this.age + ' and my class is ' + this.classNum);
};
Student.prototype.learns = function (sub) {
console.log(this.name + ' is learning ' + sub);
};
// 使用
var Bosn = new Student('bosn', 27, 'Class 3');
Bosn.hi(); // Hi, my name is bosn, my age is 27 and my class is Class 3
Bosn.LEGS_NUM; // 2 ← 繼承自 Person.prototype
Bosn.walk(); // bosn is walking !
Bosn.learns('Math');// bosn is learning Math

建構函數裡的 this 指向 new 出來的實例(Bosn),而該實例的原型指向建構函數的 prototype。這是 new 這個關鍵字默默做的三件事。
為什麼用 Object.create(Person.prototype) 而不是直接 Student.prototype = Person.prototype?因為直接賦值會讓兩者指向同一個物件。之後幫 Student 加方法時,Person 的原型上也會莫名其妙長出同樣的方法,父子類互相污染。用 Object.create 建立一個原型指向 Person.prototype 的新物件,就能各自擴充、又保有繼承關係。
Person.call(this, name, age) 是「建構子借用」:用 call 把 Person 裡的 this 硬改成新建立的 Student 實例,於是 name 與 age 就寫到實例身上了。原型屬性靠原型鏈繼承,實例屬性靠 call 借用,兩者搭配才是完整的繼承。
Student.prototype.constructor = Student 是為了修正指向。Object.create 換掉整個 prototype 之後,原本的 constructor 也一起被丟掉了,還指向 Person。不補這一句,之後用 obj.constructor 判斷型別就會得到錯誤答案。
function Person(name, age) { this.name = name; this.age = age; }
function Student() {}
Student.prototype = Person.prototype; // 寫法一
Student.prototype = Object.create(Person.prototype); // 寫法二
Student.prototype = new Person(); // 寫法三
寫法一是最糟的:兩者共享同一個原型物件,完全沒有隔離,不該使用。
寫法二是最推薦的:建立一個原型指向 Person.prototype 的空物件,既保有繼承,又不執行父類建構子(避免副作用),也不污染父類原型。
寫法三會真的呼叫一次 Person 建構子。若父類建構子裡有副作用(例如累加計數、發請求),就會被執行到,而且 name/age 會變成 undefined 的屬性掛在原型上。實務上應避免。
ES6 的 class 語法本質上就是上面這套原型的語法糖。同樣的需求現在可以寫成:
class Person {
constructor(name, age) { this.name = name; this.age = age; }
hi() { console.log(`Hi, ${this.name}`); }
walk() { console.log(`${this.name} is walking`); }
}
class Student extends Person {
constructor(name, age, classNum) {
super(name, age); // 對應 Person.call(this, ...)
this.classNum = classNum;
}
learns(sub) { console.log(`${this.name} is learning ${sub}`); }
}
extends 幫你做好了 Object.create 與 constructor 修正,super() 則取代 call。但底層機制完全一樣——搞懂原型鏈,才能明白 class 為什麼這樣設計,也才能在 Framework 裡遇到原型相關的怪問題時知道從何查起。