JavaScript 的靈活,一部分來自「同一件事有很多種寫法」。但這些寫法並非隨意可換,背後的語意差別往往就是 bug 的根源。以下從函式談到繼承。
// 函式定義:命名函式(宣告式)、匿名函式(引用式)
// 宣告式:定義程式碼先於函式執行程式碼被解析
function t1() { dwn("t1"); }
t1();
function t1() { dwn("new t1"); }
t1();
// 引用式:在函式運行中進行動態解析
var t1 = function () { dwn("new new t1"); }
t1();
var t1 = function () { dwn("new new new t1"); }
t1();
// 以上輸出:new t1、new t1、new new t1、new new new t1
很多人預期會看到 t1、new t1…,實際卻不是。關鍵就在那句註解:宣告式的定義程式碼先於執行程式碼被解析。兩個 function t1(){} 相當於對 window.t1 賦值兩次,最後一次覆蓋前一次,所以前兩次呼叫都印出 new t1。而後兩段是引用式,逐行執行、逐行賦值,因此各自印出自己的內容。
匿名函式還有幾種變體:
// 立即執行,最後一對括號用於傳入參數
(function () { ... })();
// new 之後 t1 已經是一個物件
var t1 = new function () {
var temp = 100; // 私有成員
this.temp = 200; // 公有成員
return temp + this.temp;
};
alert(typeof t1); // object
alert(t1.constructor()); // 300
// 用系統內建的 Function 建構式建立函式
var t3 = new Function('var temp = 100; this.temp = 200; return temp + this.temp;');
alert(typeof t3); // function
alert(t3()); // 300
先理解物件導向的價值:每個模組提供特定功能、彼此獨立,這種模組化帶來極大的多樣性與程式碼重用機會。就像改裝賽車,OO 讓你只需換引擎,不必整台送回原廠。
JavaScript 並非純正的 OO 語言,但透過模擬,繼承、多型、封裝都能做到。
// 1. new Object,逐個加上屬性
var a = new Object();
a.x = 1, a.y = 2;
// 2. 物件直接量(第一種的語法糖)
var b = {x: 1, y: 2};
// 3. 定義類型(類似 C# 中的類)
function Point(x, y) {
this.x = x;
this.y = y;
}
var p = new Point(1, 2);
function List() {
var m_elements = []; // 私有成員,物件外無法存取
// 若此處漏掉 var,m_elements 會變成全域變數,外部就能直接存取
m_elements = Array.apply(m_elements, arguments);
// 模擬 getter:使用時寫 alist.length
// 等價於 this.length = function(){ return m_elements.length; }
this.length = {
valueOf: function () { return m_elements.length; },
toString: function () { return m_elements.length; }
};
// 公有方法:alert(alist) 相當於 alert(alist.toString())
this.toString = function () {
return m_elements.toString();
};
// 公有方法
this.add = function () {
m_elements.push.apply(m_elements, arguments);
};
// 私有方法:涉及閉包概念
// var add = function () {
// m_elements.push.apply(m_elements, arguments);
// }
}
var alist = new List(1, 2, 3);
dwn(alist); // 輸出 1,2,3
dwn(alist.length); // 輸出 3
alist.add(4, 5, 6);
dwn(alist); // 輸出 1,2,3,4,5,6
dwn(alist.length); // 輸出 6
封裝的原理很簡單:var 宣告的變數只存在於建構函式的執行範圍內,而所有 this.xxx 的方法透過閉包參照到它,於是形成「外部看不到、內部拿得到」的效果。
// 動態公有類型、靜態公有類型(原型屬性)
function myClass() {
var p = 100; // private property
this.x = 10; // dynamic public property
}
myClass.prototype.y = 20; // static public / prototype property
// 動態為 myClass 的原型加上屬性,作用於所有已建立的實例
myClass.z = 30; // static property(類屬性)
var a = new myClass();
dwn(a.p); // undefined,私有屬性外部讀不到
dwn(a.x); // 10
dwn(a.y); // 20,沿原型鏈找到
a.x = 20;
a.y = 40;
dwn(a.x); // 20
dwn(a.y); // 40
delete a.x; // 刪除實例上的 x
delete a.y; // 刪除實例上的 y
dwn(a.x); // undefined
dwn(a.y); // 20 ← 刪掉實例屬性後,原型屬性重新可見
dwn(a.z); // undefined,類屬性無法透過實例存取
dwn(myClass.z); // 30
四種類型的行為差異:
成語「照貓畫虎」很貼切:貓是原型,虎是類型。
虎.prototype = 某隻貓;
虎.prototype = new 貓();
因為原型屬性被所有實例共享,其中一個實例改動了原型屬性的值,所有實例讀到的都會變。這點必須時時刻刻記在心裡。
原型鏈的型別關係:
function ClassA() {}
ClassA.prototype = new Object();
function ClassB() {}
ClassB.prototype = new ClassA();
function ClassC() {}
ClassC.prototype = new ClassB();
var obj = new ClassC();
dwn(obj instanceof ClassC); // true
dwn(obj instanceof ClassB); // true
dwn(obj instanceof ClassA); // true
dwn(obj instanceof Object); // true
帶預設值的 Point 物件:
function Point2(x, y) {
if (x) this.x = x;
if (y) this.y = y;
}
// 設定預設值為 0
Point2.prototype.x = 0;
Point2.prototype.y = 0;
var p1 = new Point2(); // 預設 (0,0),括號可省略也不會出錯
var p2 = new Point2(1, 2);
dwn(p1.x + "," + p1.y); // 0,0
dwn(p2.x + "," + p2.y); // 1,2
刪除實例屬性後,會回到原型上的初始狀態:
function ClassD() {
this.a = 100;
this.b = 200;
this.c = 300;
}
ClassD.prototype = new ClassD(); // 把原有屬性連同值一起設為原型
ClassD.prototype.reset = function () { // 刪除所有非原型屬性
for (var each in this) {
delete this[each];
}
};
var d = new ClassD();
dwn(d.a); // 100
d.a *= 2; d.b *= 2; d.c *= 2;
dwn(d.a); // 200
dwn(d.b); // 400
dwn(d.c); // 600
d.reset(); // 刪掉非原型屬性,全部回到原型
dwn(d.a); // 100
dwn(d.b); // 200
dwn(d.c); // 300
1. 構造繼承法
// 定義 Collection 類型
function Collection(size) {
this.size = function () { return size; }; // 公有方法,可被繼承
}
Collection.prototype.isEmpty = function () { // 靜態方法,不能被繼承
return this.size() == 0;
};
// ArrayList 繼承 Collection
function ArrayList() {
var m_elements = []; // 私有成員,不能被繼承
m_elements = Array.apply(m_elements, arguments);
this.base = Collection;
this.base.call(this, m_elements.length); // 借用父類建構式
this.add = function () {
return m_elements.push.apply(m_elements, arguments);
};
this.toArray = function () { return m_elements; };
}
ArrayList.prototype.toString = function () {
return this.toArray().toString();
};
// SortedList 繼承 ArrayList
function SortedList() {
this.base = ArrayList;
this.base.apply(this, arguments);
this.sort = function () {
var arr = this.toArray();
arr.sort.apply(arr, arguments);
};
}
var a = new ArrayList(1, 2, 3);
dwn(a);
dwn(a.size()); // 從 Collection 繼承而來
dwn(a.isEmpty); // 沒有繼承到 prototype 上的 isEmpty
var b = new SortedList(3, 1, 2);
b.add(4, 0); // 從 ArrayList 繼承
dwn(b.toArray()); // 從 ArrayList 繼承
b.sort(); // 自己實作
dwn(b.toArray());
dwn(b.size()); // 從 Collection 繼承
2. 原型繼承法
function Point(dimension) {
this.dimension = dimension;
}
function Point2D(x, y) {
this.x = x;
this.y = y;
}
Point2D.prototype.distance = function () {
return Math.sqrt(this.x * this.x + this.y * this.y);
};
Point2D.prototype = new Point(2); // Point2D 繼承 Point
function Point3D(x, y, z) {
this.x = x;
this.y = y;
this.z = z;
}
Point3D.prototype = new Point(3); // Point3D 也繼承 Point
var p1 = new Point2D(0, 0);
var p2 = new Point3D(0, 1, 2);
dwn(p1.dimension); // 2
dwn(p2.dimension); // 3
dwn(p1 instanceof Point2D); // true
dwn(p1 instanceof Point); // true
dwn(p2 instanceof Point); // true
3. 實例繼承法——用來解決前兩種對內建物件的無效
// 構造繼承的局限
function MyDate() {
this.base = Date;
this.base.apply(this, arguments);
}
var date = new MyDate();
alert(date.toGMTString); // undefined,並沒有繼承到 Date 的方法
// 原型繼承也無效
function MyDate() {}
MyDate.prototype = new Date();
var date = new MyDate();
alert(date.toGMTString); // 不是日期物件,仍然沒有繼承到
// 實例繼承法
function MyDate() {
var instance = new Date(); // 建立一個真正的日期物件
instance.printDate = function () { // 對它擴充方法
document.write("<p> " + instance.toLocaleString() + "</p> ");
};
return instance; // 把它作為建構式的回傳值
}
var myDate = new MyDate();
dwn(myDate.toGMTString()); // 成功輸出時間字串,myDate 已是 Date 的實例
myDate.printDate(); // 若沒有 return instance,將無法以下標存取
核心物件之所以無法用前兩種方式繼承,是因為它們不像自訂物件那樣在建構函式裡做賦值或初始化。
4. 拷貝繼承法(不推薦)
Function.prototype.extends = function (obj) {
for (var each in obj) {
this.prototype[each] = obj[each]; // 一對一複製屬性
} // 又慢又容易出問題
};
var Point2D = function () {
// ……
};
Point2D.extends(new Point());
5. 混合繼承法——實務上最常用
function Point2D(x, y) {
this.x = x;
this.y = y;
}
function ColorPoint2D(x, y, c) {
Point2D.call(this, x, y); // 構造繼承:呼叫父類建構式
// 等價於:
// this.base = Point2D;
// this.base.call(this, x, y);
this.color = c;
}
ColorPoint2D.prototype = new Point2D(); // 原型繼承:以 Point2D 物件為原型
混合繼承之所以成為主流,是因為它同時拿到兩邊的優點:用構造繼承保證每個實例都有自己的屬性副本,用原型繼承把方法掛在共享的原型上,避免每次 new 都複製一份函式。
今天寫 ES6,這一切有了統一的語法:
class ColorPoint2D extends Point2D {
constructor(x, y, c) {
super(x, y);
this.color = c;
}
}
extends 就是「構造繼承 + 原型鏈串接」的語法糖,super 就是 Point2D.call(this, ...)。語法變乾淨了,但底下跑的都是上面這些機制——理解原型,才能解釋為什麼方法該放 prototype 而不是 this,也才能判斷一個屬性改動會不會影響到其他實例。