判斷型別時,第一個想到的多半是 typeof。但 typeof 有個明顯盲點:只要是參考型別,不論實際上是陣列、日期還是自訂物件,一律回報 "object"。ECMAScript 因此引入 instanceof 來補這個洞。它與 typeof 一樣用來辨識物件型別,但要求開發者明確指定要比對的型別。
var oStringObject = new String("hello world");
console.log(oStringObject instanceof String); // true
這段程式問的是「oStringObject 是否為 String 物件的實例」。雖然彈性不如 typeof,但在 typeof 只回得出 "object" 的場合,instanceof 正好補位。
最典型的用途就是判斷實例是否屬於某個型別:
function Foo() {}
var foo = new Foo();
console.log(foo instanceof Foo); // true
更實用的是在繼承結構中判斷實例是否屬於父型別:
function Aoo() {}
function Foo() {}
Foo.prototype = new Aoo(); // JavaScript 原型繼承
var foo = new Foo();
console.log(foo instanceof Foo); // true
console.log(foo instanceof Aoo); // true
上面只驗了一層,多層繼承同樣適用,因為查找會一路走到原型鏈末端。
console.log(Object instanceof Object); // true console.log(Function instanceof Function); // true console.log(Number instanceof Number); // false console.log(String instanceof String); // false console.log(Function instanceof Object); // true console.log(Foo instanceof Function); // true console.log(Foo instanceof Foo); // false
為什麼 Object 與 Function 對自己為 true,其他型別對自己卻是 false?要解開這題需要兩把鑰匙:語言規範對這個運算符的定義,以及 JavaScript 的原型繼承機制。
function instance_of(L, R) { // L 為左運算式,R 為右運算式
var O = R.prototype; // 取 R 的顯示原型
L = L.__proto__; // 取 L 的隱式原型
while (true) {
if (L === null) return false;
if (O === L) return true; // 關鍵:O 嚴格等於 L 時才成立
L = L.__proto__;
}
}
接著把前面那幾題逐一代入推演。
Object instanceof Object
ObjectL = Object, ObjectR = Object; O = ObjectR.prototype = Object.prototype L = ObjectL.__proto__ = Function.prototype // 第一次 O != L,繼續往上 L = Function.prototype.__proto__ = Object.prototype // 第二次 O == L → true
Function instanceof Function
FunctionL = Function, FunctionR = Function; O = FunctionR.prototype = Function.prototype L = FunctionL.__proto__ = Function.prototype // 第一次 O == L → true
Foo instanceof Foo
FooL = Foo, FooR = Foo; O = FooR.prototype = Foo.prototype L = FooL.__proto__ = Function.prototype // 第一次 O != L,繼續往上 L = Function.prototype.__proto__ = Object.prototype // 第二次 O != L,繼續往上 L = Object.prototype.__proto__ = null // 第三次 L == null → false
差別在於 Object 與 Function 的原型鏈裡恰好繞得回自己,而一般函式繞不回去。
JavaScript 本身沒有多重繼承的概念,但 Dojo 的 declare 允許一個類別繼承自多個類別。以 Dojo 1.6.1 為例:
dojo.declare("Aoo", null, {});
dojo.declare("Boo", null, {});
dojo.declare("Foo", [Aoo, Boo], {});
var foo = new Foo();
console.log(foo instanceof Aoo); // true
console.log(foo instanceof Boo); // false
console.log(foo.isInstanceOf(Aoo)); // true
console.log(foo.isInstanceOf(Boo)); // true
Foo 明明宣告繼承了 Aoo 與 Boo,用 instanceof 檢查 Boo 卻是 false。原因在實作層面:Dojo 內部 Foo 的 prototype 鏈上仍然只有 Aoo,Boo 的成員是靠 mixin 機制複製進來的,並未進入原型鏈。為此 Dojo 替每個實例加上 isInstanceOf 方法,專門用來查多重繼承的歸屬。這也側面說明 instanceof 的判定完全取決於原型鏈結構,而非宣告時寫了什麼。