摘要：注意基本變量類型不是對象類型，只有基本包裝類型才是對象類型。至于顯示的原型，在里用屬性表示，這個是原型繼承的基礎(chǔ)知識，在這里就不在敘述了。

如果你要開發(fā)一個復(fù)雜的產(chǎn)品，那么肯定少不了使用面向?qū)ο髾C制，當然也避不開 Javascript 里面的繼承，instanceof 運算符是原生 Javascript 語言中用來判斷實例繼承的操作符。所以我們有必要深入理解該運算符！

　　在 JavaScript 中，要判斷某個變量的類型，我們第一個想起的就是 typeof 運算符，但是在使用 typeof 運算符的時候 ，只要是引用類型存儲的變量，無論你引用的是什么類型的對象，統(tǒng)一返回 “object” ，這就是一個大問題，我們?nèi)绾闻袛噙@個對象是屬于哪個類型的呢？ ECMAScript 引入了在Java 中的instanceof運算符來解決這個問題，instanceof與typeof都可以檢測數(shù)據(jù)類型，instanceof 運算符與 typeof 運算符的不同點是：要求開發(fā)者明確的確認檢測對象為某特定類型的數(shù)據(jù)

　　這個網(wǎng)上有很多種說法，說法很多的原因也很簡單，就是因為在JS一切皆對象，一切引用類型都是繼承于 Object 類型的。我在這里分為幾大類

 undefiend 沒有定義數(shù)據(jù)類型
 number 數(shù)值數(shù)據(jù)類型 例如 10或者1或者5.5
 string 字符串數(shù)據(jù)類型用來描述文本 例如 "你的姓名"
 boolean 布爾類型 true|false  不是正就是反，是或者否，有或者沒有
 object 對象類型 復(fù)雜的一組描述信息的集合
 function 函數(shù)類型 

這么分的根據(jù)是什么呢？很簡單，就是通過 typeof 來區(qū)分的

function Fun(){}
var unde = typeof abc;    // 基本類型
var numb = typeof 300;    // 基本類型
var str  = typeof "hello";    // 基本類型
var bool = typeof true;       // 基本類型
var func = typeof function(){}   // 引用/對象 類型
var obje = typeof new String("hello");   // 引用/對象 類型
var nul = typeof null;    // 引用/對象 類型
var obj = typeof new Fun()   // 引用/對象 類型
console.log("
",unde,"
",numb,"
",str,"
",bool,"
",func,"
",obje);
console.log("
",obj,"
",nul)

結(jié)果為：

從中可以看出，typeof 就只能返回這六種數(shù)據(jù)類型，所以基本類型就確定為這六種。其實函數(shù) function 也是對象類型，這個問題后面會講到的。
注意 ： 基本變量類型不是對象類型，只有基本包裝類型才是對象類型。所以 str instanceof Object/String 都是 false

var StringObje = new String("instanceof");
console.log(StringObje instaceof String); // 輸出為true

這段代碼問的是，變量 StringObje 是不是 String 對象的實例，答案為 true，很顯然是的 , typeof 只會返回 "Object"，所以 instanceof 還是有用的，當然你會發(fā)現(xiàn) StringObje instanceof Object 也是true
通常來講使用 instanceof 就是判斷一個實例是否屬于某種類型

// 判斷 foo 是否是 Foo 的實例
function Foo(){}
var foo = new Foo();
console.log(foo instaceof Foo)  // true

// 判斷 a 是否是A類的實例，和是否是其父類 AFather 的實例
function AFather(){}
function A(){}
AFather.prototype = new A(){};  // js原型繼承
var a = new A();
console.log(a instanceof A)  //true
console.log(a instanceof AFather)   //true

在多層繼承中，仍然適用。

function Foo(){}
console.log(Object instanceof Object);//1  true 
console.log(Function instanceof Function);//2  true 
console.log(Number instanceof Number);//3  false 
console.log(String instanceof String);//4  false 
console.log(Function instanceof Object);//5   true 
console.log(Foo instanceof Function);//6  true 
console.log(Foo instanceof Foo);//7  false

對上面的結(jié)果有沒有感覺到奇怪，奇怪也正常，因為確實挺奇怪的！
對上面的分析，首先要看看，你檢測的到底是什么？

console.log(Object,Function,String,Number,Foo);
  /***
  *  結(jié)果如下
  *   function Object() { [native code] } 
  *   function Function() { [native code] } 
  *   function String() { [native code] } 
  *   function Number() { [native code] } 
  *   function Foo(){}
  */

這已經(jīng)很明顯了，所有的檢測對象都是一個函數(shù)，那么必定屬于函數(shù)類型和對象類型，只剩下3,4,7有問題了，那么為什么是 false 呢？你想想，Foo函數(shù)是Foo的實例嗎？顯然不是啊，同理，String和Number函數(shù)也不是其本身的實例，new Func() , 這個才是實例對象。
想徹底明白其中奧妙，必須要了解語言規(guī)范和原型繼承機制

可以參考這個網(wǎng)址 ：instanceof 語法
　　規(guī)范定義很晦澀，而且看起來比較復(fù)雜，涉及到很多概念，但把規(guī)范翻譯成 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 時，返回 true 
    L = L.__proto__; 
  } 
 }

　　本文主要在分析 JavaScript instanceof 運算符，對于 JavaScript 的原型繼承機制不再做詳細的講解，下面參考來自http://www.mollypages.org/mis... 的一張圖片，此圖片詳細的描述了 JavaScript 各種對象的顯示和隱式原型鏈結(jié)構(gòu)。
　　由其涉及顯示原型和隱式原型，所以下面對這兩個概念作一下簡單說明。在 JavaScript 原型繼承結(jié)構(gòu)里面，規(guī)范中用 [[Prototype]] 表示對象隱式的原型，在 JavaScript 中用 __proto__ 表示，并且在 Firefox 和 Chrome 瀏覽器中是可以訪問得到這個屬性的，但是 IE 下不行。所有 JavaScript 對象都有 __proto__ 屬性，但只有 Object.prototype.__proto__ 為 null，前提是沒有在 Firefox 或者 Chrome 下修改過這個屬性。這個屬性指向它的原型對象。 至于顯示的原型，在 JavaScript 里用 prototype 屬性表示，這個是 JavaScript 原型繼承的基礎(chǔ)知識，在這里就不在敘述了。

這個圖片很好地表達了js原型鏈的關(guān)系，要仔細去看，跟著箭頭一步一步分析。

如果你理解了 javascript 原型鏈，那么這個問題就簡單了！
下面將詳細講解 Object instanceof Object，F(xiàn)unction instanceof Function 和 Foo instanceof Foo 三個示例，其它示例讀者可自行推演。

 1. Object instanceof Object

 // 為了方便表述，首先區(qū)分左側(cè)表達式和右側(cè)表達式
 ObjectL = Object, ObjectR = Object; 
 // 下面根據(jù)規(guī)范逐步推演
 O = ObjectR.prototype = Object.prototype 
 L = ObjectL.__proto__ = Function.prototype 
 // 第一次判斷
 O != L 
 // 循環(huán)查找 L 是否還有 __proto__ 
 L = Function.prototype.__proto__ = Object.prototype 
 // 第二次判斷
 O == L 
 // 返回 true

 2. Function instanceof Function

 // 為了方便表述，首先區(qū)分左側(cè)表達式和右側(cè)表達式
 FunctionL = Function, FunctionR = Function; 
 // 下面根據(jù)規(guī)范逐步推演
 O = FunctionR.prototype = Function.prototype 
 L = FunctionL.__proto__ = Function.prototype 
 // 第一次判斷
 O == L 
 // 返回 true

 3. Foo instanceof Foo

 // 為了方便表述，首先區(qū)分左側(cè)表達式和右側(cè)表達式
 FooL = Foo, FooR = Foo; 
 // 下面根據(jù)規(guī)范逐步推演
 O = FooR.prototype = Foo.prototype 
 L = FooL.__proto__ = Function.prototype 
 // 第一次判斷
 O != L 
 // 循環(huán)再次查找 L 是否還有 __proto__ 
 L = Function.prototype.__proto__ = Object.prototype 
 // 第二次判斷
 O != L 
 // 再次循環(huán)查找 L 是否還有 __proto__ 
 L = Object.prototype.__proto__ = null 
 // 第三次判斷
 L == null 
 // 返回 false