DIV CSS 佈局教程網

JavaScript 原型與原型鏈完全解析
編輯:JavaScript基礎知識     

在 JavaScript 的世界裡,原型(prototype)與原型鏈(prototype chain)堪稱面試與日常開發中的必考知識點。理解它們,等於掌握了這門語言物件導向機制的鑰匙。本文將從最基礎的概念出發,層層遞進地帶你走進原型的世界。

從 prototype 屬性說起

可以這麼理解:JavaScript 中幾乎每個物件都關聯著一個 prototype 屬性,它保存著對另一個物件的引用,而被引用的這個物件,往往充當著當前物件的「父級」角色。

A.prototype = new B();

需要特別提醒的是,理解 prototype 時不要把它和繼承混為一談。A 的 prototype 是 B 的一個實例,你可以把它想象成 A 把 B 的屬性與方法完整地「複製」了一份過來,於是 A 就能使用 B 的能力。這裡強調的是複製,而非繼承。甚至可以出現 A 的 prototype 是 B 的實例、而 B 的 prototype 又是 A 的實例這種情況。

私有變量與私有函數

在一個函數內部定義的變量和函數,如果不對外暴露任何接口,那麼外部是無法訪問的,它們就成為了這個函數的私有成員。

<script type="text/javascript">
  function Box(){
    var color = "blue";      // 私有變量
    var fn = function(){     // 私有函數
    }
  }
  var obj = new Box();
  alert(obj.color);  // undefined
  alert(obj.fn);     // undefined
</script>

可以看到,在 Box 外部根本拿不到 color 和 fn,它們被牢牢地封裝了起來。

靜態變量與靜態函數

定義好一個函數後,通過點號「.」為它掛上的屬性和函數,函數本身依然可以訪問,但它的實例卻無法訪問。這樣的成員被稱為靜態變量與靜態函數。

<script type="text/javascript">
  function Obj(){};
  Obj.num = 72;                 // 靜態變量
  Obj.fn = function(){          // 靜態函數
  }
  alert(Obj.num);        // 72
  alert(typeof Obj.fn);  // function
  var t = new Obj();
  alert(t.name);         // undefined
  alert(typeof t.fn);    // undefined
</script>

實例變量與實例方法

在物件導向編程中,我們往往希望在定義物件的同時就定義好屬性和方法,實例化之後即可訪問,JavaScript 同樣能做到。

<script type="text/javascript">
  function Box(){
    this.a = [];             // 實例變量
    this.fn = function(){    // 實例方法
    }
  }
  console.log(typeof Box.a);   // undefined
  console.log(typeof Box.fn);  // undefined
  var box = new Box();
  console.log(typeof box.a);   // object
  console.log(typeof box.fn);  // function
</script>

為實例變量和方法新增屬性後,我們會發現一個有趣的現象:

<script type="text/javascript">
  function Box(){
    this.a = [];
    this.fn = function(){
    }
  }
  var box1 = new Box();
  box1.a.push(1);
  box1.fn = {};
  console.log(box1.a);        // [1]
  console.log(typeof box1.fn);// object

  var box2 = new Box();
  console.log(box2.a);        // []
  console.log(typeof box2.fn);// function
</script>

box1 改動了 a 和 fn,box2 卻不受影響。由於數組和函數都是引用類型的物件,這說明 box1 與 box2 中同名的屬性和方法並非同一個引用,而是各自持有的一份複製。

對屬性而言這還無傷大雅,但對方法來說問題就大了:每個方法本質上都在做同樣的事,卻被複製了無數份。如果一個構造函數有成千上萬個實例方法,那麼每個實例都要背著上千份的方法副本,這顯然極不科學。於是,prototype 應運而生。

原型的基本概念

我們創建的每個函數都有一個 prototype 屬性,它是一個指針,指向一個物件。這個物件的用途是容納所有該類型實例都能共享的屬性和方法。換句話說,prototype 就是通過構造函數創建出的實例所共享的那個原型物件。

使用原型的最大好處,就在於讓物件實例共享其中的屬性和方法。也就是說,我們不必把這些資訊塞進構造函數裡,而是直接掛到原型上。構造函數的老問題——每個方法都要在每個實例裡創建一遍——就此迎刃而解。

在 JavaScript 中,值可以分為原始值和物件值兩大類。每個物件都有一個內部屬性 prototype,我們通常稱之為原型。原型的值可以是一個物件,也可以是 null;如果是一個物件,那麼這個物件同樣擁有自己的原型。如此一層層向上,就形成了一條線性的鏈條,這便是原型鏈。

原型的核心含義

函數可以作為構造函數使用。只有函數才具備可訪問的 prototype 屬性,而物件實例並沒有這個屬性,它只有一個內部、通常不可直接訪問的 __proto__ 屬性。__proto__ 是物件指向其相關原型的一條神秘鏈接。按照標準,__proto__ 本是不對外公開的私有屬性,但 Firefox 的引擎將它暴露出來,讓我們能夠讀取與設置。

<script type="text/javascript">
  var Browser = function(){};
  Browser.prototype.run = function(){
    alert("I'm Gecko, a kernel of firefox");
  }
  var Bro = new Browser();
  Bro.run();
</script>

當我們調用 Bro.run() 時,由於 Bro 自身並沒有這個方法,於是它會沿著 __proto__ 去 Browser.prototype 上查找,最終執行到 run()。(本系列中首字母大寫的函數都代表構造函數,用以區分普通函數。)

當你使用構造函數創建實例時,實例內部會包含一個指針(__proto__)指向構造函數的 prototype。這個連接存在於實例與構造函數的 prototype 之間,而不是實例與構造函數本身之間。

<script type="text/javascript">
  function Person(name){       // 構造函數
    this.name = name;
  }
  Person.prototype.printName = function(){  // 原型物件
    alert(this.name);
  }
  var person1 = new Person('Byron');  // 實例化物件
  console.log(person1.__proto__);     // Person
  console.log(person1.constructor);   // 自己試試看
  console.log(Person.prototype);      // 指向原型物件
  var person2 = new Person('Frank');
</script>

Person 的實例 person1 包含了 name 屬性,同時自動生成一個 __proto__ 屬性,指向 Person 的 prototype,因此可以訪問到原型裡定義的 printName 方法:

每個 JavaScript 函數都有 prototype 屬性,它引用一個物件,也就是原型物件。原型物件初始化時是空的,我們可以在裡面自定義任意屬性和方法,這些成員都將被該構造函數創建的物件所繼承。

構造函數、實例與原型物件的關係

那麼,三者之間究竟有何關聯?理清下面幾點就清晰了:

實例由構造函數創建,一經創造便擁有 constructor 屬性(指向構造函數)和 __proto__ 屬性(指向原型物件);構造函數中有一個 prototype 屬性,是指向原型物件的指針;原型物件內部也有一個指針(constructor 屬性)指回構造函數,即 Person.prototype.constructor = Person; 而實例可以訪問原型物件上定義的屬性和方法。

再舉個例子:

<script type="text/javascript">
  function Animal(name){   // 構造函數
    this.name = name;      // 設置物件屬性
  }
  Animal.prototype.behavior = function(){  // 為 prototype 添加 behavior 方法
    alert("this is a " + this.name);
  }
  var Dog = new Animal("dog");  // 創建 Dog 物件
  var Cat = new Animal("cat");  // 創建 Cat 物件
  Dog.behavior();
  Cat.behavior();       // 輸出 "this is a cat"
  alert(Dog.behavior == Cat.behavior);  // true
</script>

從運行結果可以看出,構造函數 prototype 上定義的方法能被物件直接調用,而且代碼是共享的。(試著把 Animal.prototype.behavior 中的 prototype 去掉,看看還能不能運行。)在這裡,prototype 指向 Animal 物件。

數組物件的實例

再看一個數組物件的例子。當我們創建 array1 這個物件時,它在 JavaScript 引擎中的物件模型如下:

var array1 = [1,2,3];

array1 有一個 length 屬性,值為 3,但我們可以通過下面的方式為它增加元素:

array1.push(4);

push 這個方法來自 array1 的 __proto__ 成員所指向物件的成員方法(Array.prototype.push())。正是因為所有通過 [] 創建的數組物件都包含一個指向同一個物件(Array.prototype)的 __proto__,這些數組才能共享 push、reverse 等方法。

函數物件的實例

function Base() {
  this.id = "base"
}

var obj = new Base();

那麼 new 操作符到底做了什麼?其實很簡單,就三件事:

var obj  = {};
obj.__proto__ = Base.prototype;
Base.call(obj);

原型鏈

所謂原型鏈,是指當你從一個物件上取屬性或方法時,如果該物件自身沒有,就會去它關聯的 prototype 物件上尋找;若還沒有,就繼續沿著前輩的 prototype 向上查找,如此類推,直到 Prototype……Prototype 為 undefined(Object 的 Prototype 就是 undefined)為止,這條查找路徑便構成了「原型鏈」。

<script type="text/javascript">
  function Shape(){
    this.name = "shape";
    this.toString = function(){
      return this.name;
    }
  }
  function TwoShape(){
    this.name = "2 shape";
  }
  function Triangle(side,height){
    this.name = "Triangle";
    this.side = side;
    this.height = height;
    this.getArea = function(){
      return this.side*this.height/2;
    }
  }
  TwoShape.prototype = new Shape();
  Triangle.prototype = new TwoShape();
</script>

這裡用構造器 Shape() 新建了一個實例,再用它去覆蓋該物件的原型。為保證 constructor 指向正確,通常還需補上:

<script type="text/javascript">
  function Shape(){
    this.name = "shape";
    this.toString = function(){
      return this.name;
    }
  }
  function TwoShape(){
    this.name = "2 shape";
  }
  function Triangle(side,height){
    this.name = "Triangle";
    this.side = side;
    this.height = height;
    this.getArea = function(){
      return this.side*this.height/2;
    }
  }
  TwoShape.prototype = new Shape();
  Triangle.prototype = new TwoShape();
  TwoShape.prototype.constructor = TwoShape;
  Triangle.prototype.constructor = Triangle;
  var my = new Triangle(5,10);
  my.getArea();
  my.toString();   // Triangle
  my.constructor;  // Triangle(side,height)
</script>

原型繼承

在原型鏈的末端,就是 Object 構造函數 prototype 屬性所指的那個原型物件。它是所有物件的祖先,實現了 toString 等所有物件天生就該具備的方法。Function、Boolean、String、Date、RegExp 等內置構造函數的 prototype 都從這個「老祖宗」傳承而來,同時又各自定義了自己的屬性和方法,於是它們的子孫便表現出各宗族不同的特徵。

在 ECMAScript 中,實現繼承的方式就是依靠原型鏈。

<script type="text/javascript">
  function Box(){   // 被繼承的函數叫超類型(父類、基類)
    this.name = "Jack";
  }
  function Tree(){  // 繼承的函數叫子類型(子類、派生類)
    this.age = 300;
  }
  Tree.prototype = new Box();  // Tree 繼承了 Box,通過原型形成鏈條
  var tree = new Tree();
  alert(tree.name);  // 彈出 Jack
</script>

原型鏈雖然強大,但也存在問題。最主要的一個問題來自包含引用類型值型的原型屬性:包含引用類型的原型屬性會被所有實例共享,這也正是為什麼我們要在構造函數中、而不是在原型物件中定義屬性的原因。通過原型實現繼承時,原型實際上會變成另一個類型的實例,於是原本屬於實例的屬性也就搖身一變成了原型的屬性。

此外,創建子類型實例時,無法向超類型的構造函數傳遞參數——準確地說,是沒有辦法在不影響所有物件實例的前提下給超類型構造函數傳參。再加上原型中包含引用類型值帶來的困擾,實踐中很少有人單獨使用原型鏈。

再看個例子:

<script type="text/javascript">
  function Person(name){
    this.name = name;   // 設置物件屬性
  };
  Person.prototype.company = "Microsoft";  // 設置原型的屬性
  Person.prototype.SayHello = function(){  // 原型的方法
    alert("Hello, I'm " + this.name + " of " + this.company);
  };
  var BillGates = new Person("BillGates");
  BillGates.SayHello();  // "Hello, I'm BillGates of Microsoft"
  var Jobs = new Person("Jobs");
  Jobs.company = "Apple";  // 設置自己的 company,掩蓋了原型的屬性
  Jobs.SayHello = function(){
    alert("Hi, " + this.name + " like " + this.company);
  };
  Jobs.SayHello();     // "Hi, Jobs like Apple"
  BillGates.SayHello(); // Jobs 的覆蓋不影響原型,BillGates 照舊輸出
</script>

再看一個原型鏈的例子:

<script type="text/javascript">
  function Year(){
    this.value = 21;
  }
  Year.prototype = {
    method:function(){
    }
  };
  function Hi(){
  };
  Hi.prototype = new Year();  // 設置 Hi 的 prototype 為 Year 的實例
  Hi.prototype.year = 'Hello World';
  Hi.prototype.constructor = Hi;
  var test = new Hi();  // 創建 Hi 的新實例

  // 原型鏈
  test [Hi 的實例]
    Hi.prototype [Year 的實例]
      {year:'Hello World'}
      Year.prototype
          {method:……};
          object.prototype
            {toString:...};
</script>

從這個例子可以看到,test 物件從 Hi.prototype 和 Year.prototype 中繼承下來,因此它既能訪問 Year 的原型方法 method,也能訪問實例屬性 value。

__proto__ 屬性

__proto__ 屬性(IE 瀏覽器不支持)是指向原型物件的一個指針,其作用是指向構造函數的 prototype,透過它我們就能訪問原型裡的屬性和方法。

JavaScript 中的物件實例本質上由一系列屬性組成,其中有一個內部不可見的特殊屬性——__proto__,它的值指向該實例的原型,而一個實例只擁有唯一一個原型。

<script type="text/javascript">
  function Box(){   // 大寫,代表構造函數
    Box.prototype.name = "trigkit4";  // 原型屬性
    Box.prototype.age = "21";
    Box.prototype.run = function(){   // 原型方法
      return this.name + this.age + 'studying';
    }
  }
  var box1 = new Box();
  var box2 = new Box();
  alert(box1.constructor);  // 構造屬性,可獲取構造函數本身
</script>

__proto__ 與 prototype 的區別

prototype 是 function 物件專有的屬性;__proto__ 是普通物件的隱式屬性,在 new 的時候會指向 prototype 所指的物件。__proto__ 屬於某個實體物件,而 prototype 則屬於構造函數。__proto__ 僅建議在學習或調試環境下使用。

原型模式的執行流程

1. 先查找構造函數實例裡的屬性或方法,如果有,立即返回;
2. 如果實例裡沒有,就去它的原型物件裡找,如果有,立即返回。

原型物件與構造函數的取值規則

當實例自身沒有該屬性時,會讀取原型裡的值;一旦在實例上重新賦值,就遵循「就近原則」使用實例自己的值,而這不會影響原型,也不會影響其他實例:

<script type="text/javascript">
  function Box(){
    this.name = "Bill";
  }
  Box.prototype.name = "trigkit4";  // 原型屬性
  Box.prototype.age = "21";
  Box.prototype.run = function(){
    return this.name + this.age + 'studying';
  }
  var box1 = new Box();
  alert(box1.name);   // Bill(實例屬性優先)
  box1.name = "Lee";
  alert(box1.name);   // Lee(就近原則)
</script>

工廠模式與構造函數

工廠模式:

function createObject(name,age){
  var obj = new Object();
  obj.name = name;
  obj.age = age;
  return obj;
}

工廠模式解決了物件大量重複實例化的問題,卻留下了一個遺憾:根本無法判斷這些物件究竟是哪個類型的實例。而使用構造函數,既解決了重複實例化,又解決了物件識別的問題。

構造函數方式與工廠模式的不同之處在於:

1. 構造函數方法沒有顯式地創建物件(new Object());
2. 直接將屬性和方法賦值給 this 物件;
3. 沒有 return 語句。

當你使用構造函數並 new 它時,後台其實執行了 new Object(),函數體內的 this 就代表 new 出來的那個物件。

最後幾點值得記住:

1. 判斷屬性是在實例裡還是在原型裡,可以用 hasOwnProperty() 函數;
2. 字面量創建的方式,其 constructor 會指向 Object,而構造函數創建的方式則相反。之所以指向 Object,是因為 Box.prototype = {}; 這種寫法其實就是新建了一個物件;
3. 如果是實例方法,不同實例化的方法地址各不相同,是唯一的;
4. 如果是原型方法,那麼它們的地址是共享的。

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