DIV CSS 佈局教程網

instanceof 深入解析:從 typeof 的盲點到 Dojo 多重繼承
編輯:JavaScript基礎知識     

為什麼需要 instanceof

判斷型別時,第一個想到的多半是 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 的原型繼承機制。

把 instanceof 攤開來寫

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 的原型鏈裡恰好繞得回自己,而一般函式繞不回去。

Dojo 的多重繼承怎麼辦

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 的判定完全取決於原型鏈結構,而非宣告時寫了什麼。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved