DIV CSS 佈局教程網

深入理解 JavaScript 的動態語言特性:eval、this、原型與繼承
編輯:關於JavaScript     

JavaScript 是一種解釋型語言,而非編譯型,它無法被編譯成二進位檔案。這個特性衍生出一系列與靜態語言截然不同的行為,本文就從最典型的動態執行說起。

一、動態執行與閉包

動態執行指的是 JavaScript 提供 eval() 函式,用來把一段文字當程式碼動態解譯,並在當前上下文環境中執行。

首先要理解的是,eval() 存在兩種閉包環境:全域閉包與當前函式的閉包。看下面這段程式:

var i = 100;
function myFunc() {
  var i = 'test';
  eval('i = "hello."');
}
myFunc();
alert(i); // 100

先定義全域變數 i = 100,接著呼叫 myFunc,函式內部試圖把區域變數 i 從 'test' 改成 'hello'。由於 eval 的語義就是「立即執行一段文字」,上面這段其實等價於:

var i = 100;
function myFunc() {
  var i = 'test';
  (function(){
    return (i = "hello.");
  })();
}
myFunc();
alert(i); // 100

這樣就很清楚了:myFunc 執行後,區域變數 i 確實從 test 變成了 hello,但因為處於閉包之中,這個值外部拿不到,所以瀏覽器印出來的仍是全域的 100。

二、eval 使用全域閉包的場合

我們都知道 eval() 是 JavaScript 全域物件 Global 上的方法,而要存取 Global,在瀏覽器環境中通常透過宿主物件 window。照理說下面這段也該印出 100:

var i = 100;
function myFunc() {
  var i = 'test';
  window.eval('i="hello."');
}
myFunc();
alert(i);

然而結果並不一致:在 IE 下,不論寫 window.eval() 還是 eval(),輸出的都是 100;但在標準瀏覽器下,window.eval() 輸出 hello,eval() 輸出 100。原因在於 IE 採用的是 JScript 引擎,標準瀏覽器則多為 SpiderMonkey 系引擎,兩者對 eval() 所使用的閉包環境理解不同。

也就是說,在標準瀏覽器下印出 hello,IE 下印出 100。另一種寫法效果相同,都是賦予 eval 存取全域閉包的能力:

var i = 100;
function myFunc() {
  var i = 'test';
  // window.eval('i="hello."');
  eval.call(window, 'i="hello"');
}
myFunc();
alert(i);

但 IE 的 JScript 引擎裡 eval() 並不具備這種能力,印出的永遠是 100。不過 IE 提供了另一條路:window.execScript() 中執行的程式碼總是在全域閉包中執行。

var i = 100;
function myFunc() {
  var i = 'test';
  window.execScript('i="hello."');
  // eval.call(window, 'i="hello"');
}
myFunc();
alert(i); // 印出 hello

可以這樣歸納:JScript 引擎用 execScript() 把 eval 在全域閉包與函式閉包上的差異分離出來;Mozilla 引擎則用 eval() 的不同呼叫形式來區分。實作方式不同,但都能達到存取全域閉包的目的。

三、eval 使用當前函式閉包

一般情況下,eval() 使用的就是當前函式的閉包:

var i = 100;
function myFunc() {
  var i = 'test';
  eval('i="hello."');
}
myFunc();
alert(i); // 100

因為 eval 作用的範圍在函式內部,改的是區域變數,所以印出來的是全域的 100。

另外要記住:eval() 會把傳入的內容視為一個程式碼區塊,區塊中放的是語句、複合語句或語句組。因此取得基本值完全沒問題:

eval('true');            // true
eval('"this is a char"'); // string
eval('3');               // 數字 3

但用同樣的方式取物件就會出錯:

eval('{name:"MyName",value:1}');

報錯訊息是 Uncaught SyntaxError: Unexpected。原因在於 eval 把一對大括號當成複合語句來解析:

· 第一個冒號成了「標籤宣告」的標示符;
· name 成了標籤;
· MyName 成了字串直接量;
· value 成了變數標示符;
· 第二個冒號無法合理進行語法分析,於是拋出語法異常。

如果只有一段,反而不會報錯:

eval('{name:"MyName"}')   // 輸出 "MyName"

要解決這個問題,只要外面再包一層小括號,讓它成為一個表達式語句:

eval('({name:"MyName",value:1})')   // Object {name: "MyName", value: 1}

但要注意另一個相容性陷阱:匿名函式加上小括號後,在 IE 下會失效:

var func = eval('(function(){})');
alert(typeof func); // IE 下是 undefined

在 Chrome 與 Firefox 中印出的是 function,IE 的 JScript 引擎卻印出 undefined。這種情況下可以改用具名函式來繞過:

eval('function func(){}');
alert(typeof func); // 印出 function

實務上最常見的用法,是處理 ajax 從伺服器端取回的字串格式資料,把它轉成物件:

// 假設伺服器回傳如下字串,想轉成 json 物件
var data = '{"name":"Mike","sex":"女","age":"29"}';
console.log(eval("(" + data + ")"));   // Object {name: "Mike", sex: "女", age: "29"}

// 或者直接寫成
console.log(eval("(" + '{"name":"Mike","sex":"女","age":"29"}' + ")"));

還有一點必須明白:使用 eval 或 with 都會改變作用域,這也是它們效能較差、且容易被濫用的原因:

var i = 100;
function myFunc(name) {
  console.log('value is:' + i);  // 100
  eval(name);
  console.log('value is:' + i);  // 10
}
myFunc('var i = 10;');

第一次印出 100,第二次執行 eval 後作用域被拉進函式內部,i 就變成 10 了。基於這個副作用,現代實務普遍建議改用 JSON.parse() 來解析資料,並在打包工具(如 ESLint)中禁用 eval。

四、動態方法呼叫:call 與 apply

JavaScript 有三種執行體:一是 eval() 參數中的字串,它總是被當成當前函式上下文中的語句執行;二是 new Function(){} 傳入的字串,它被當成一個全域匿名函式閉包中的語句執行;三是函式本身,透過呼叫運算子「()」執行。除此之外,現在還可以透過 call() 或 apply() 作為動態方法來執行:

function foo(name){
  alert("hi:" + name);
}

foo.call(null, 'longen');      // hi: longen
foo.apply(null, ['tugenhua']); // hi: tugenhua

call() 與 apply() 效果相同,都是呼叫函式,唯一差別在第二個參數:apply 的第二個參數必須是陣列或 arguments。

五、call 與 apply 中的 this 引用

如果把一個普通函式當成某個物件的方法來呼叫,就能動態決定 this 的指向。先看一個普通函式:

function foo(){
  alert(this.name);
}

接著定義兩個物件:

var obj1 = {name: 'obj1'};
var obj2 = new Object();
obj2.name = 'obj2';

分別用這兩個物件去呼叫 foo:

function foo(){ alert(this.name); }

var obj1 = {name: 'obj1'};
var obj2 = new Object();
obj2.name = 'obj2';

foo.call(obj1);   // obj1
foo.call(obj2);   // obj2

第一次印出 obj1,第二次印出 obj2——也就是說 this 指標分別被指向了 obj1 與 obj2。

既然方法呼叫時能查到 this 引用,那麼我們也能把 this 當參數往內傳:

function foo(){
  alert(this.name);
}

function MyObject(){
  this.name = 'myObject';
}

MyObject.prototype.doAction = function(){
  foo.call(this);
};

// 測試
var obj3 = new MyObject();
obj3.doAction();

先將 MyObject 實例化得到 obj3,呼叫 obj3 的 doAction 時,this 指向 obj3,而 obj3.name 是 'myObject',因此 foo.call(this) 裡的 this 同樣指向 obj3,最後彈出 myObject。

參數也能照樣傳遞:

function calc_area(w, h) {
  alert(w * h);
}

function Area() {
  this.name = 'MyObject';
}

Area.prototype.doCalc = function(v1, v2){
  calc_area.call(this, v1, v2);
};

var area = new Area();
area.doCalc(10, 20);

這裡給 call 傳了兩個參數。改用 apply 也完全等價,只是參數要放進陣列:

function calc_area(w, h) {
  alert(w * h);
}

function Area() {
  this.name = 'MyObject';
}

Area.prototype.doCalc = function(v1, v2){
  // calc_area.call(this, v1, v2);
  calc_area.apply(this, [v1, v2]);
};

var area = new Area();
area.doCalc(10, 20);

六、理解 JavaScript 物件屬性

Object.defineProperty 是 ECMAScript 5 提供的方法,接收三個參數:屬性所在的物件、要修改的屬性名稱,以及一個描述符物件。描述符的屬性必須是 configurable、enumerable、writable 與 value 中的一或多個,設定後即可修改對應的特性值。

ECMAScript 中有兩種屬性:資料屬性與存取器屬性。

1. 資料屬性

資料屬性包含一個資料值的位置,可以從該位置讀取與寫入。它有四個描述行為的特性:

· configurable:能否透過 delete 刪除屬性並重新定義、能否修改屬性特性、能否把屬性改成存取器屬性。預設 true。
· enumerable:能否透過 for-in 迴圈回傳該屬性。預設 true。
· writable:能否修改屬性的值。預設 true。
· value:包含屬性的資料值,讀取時從此處讀、寫入時把新值存回此處。預設 undefined。

標準瀏覽器支援此方法,IE8 及以下不支援。先定義一個物件:

var person = { name: 'longen' };

此時 alert(person.name) 當然是 longen。

理解 writable:

alert(person.name); // longen

Object.defineProperty(person, "name", {
  writable: false,
  value: "tugenhua"
});

alert(person.name); // tugenhua
person.name = "Greg";
alert(person.name); // tugenhua

把 writable 設為 false 之後,後續對 name 的修改都不生效;反之若設為 true 或直接不寫這一列,就能正常修改:

Object.defineProperty(person, "name", {
  writable: false,
  value: "tugenhua"
});

alert(person.name); // tugenhua
person.name = "Greg";
alert(person.name); // Greg

理解 configurable:

var person = { name: 'longen' };
alert(person.name); // longen

Object.defineProperty(person, "name", {
  configurable: false,
  value: "tugenhua"
});

alert(person.name); // tugenhua
delete person.name;
alert(person.name); // tugenhua

configurable 設為 false,代表無法用 delete 刪除 name,所以最後一個彈窗依然印出 tugenhua。若設為 true 或不寫這個屬性,最後就會是 undefined:

var person = { name: 'longen' };
alert(person.name); // longen

Object.defineProperty(person, "name", {
  value: "tugenhua"
});

alert(person.name); // tugenhua
delete person.name;
alert(person.name); // undefined

理解 enumerable:

var person = { name: 'longen' };

Object.defineProperty(person, "name", {
  enumerable: true,
  value: "tugenhua"
});

alert(person.name); // tugenhua
for (var i in person) {
  alert(person[i]); // 可以彈出
}

設為 true 時 for-in 能取到資料;設為 false 則不會回傳:

var person = { name: 'longen' };

Object.defineProperty(person, "name", {
  enumerable: false,
  value: "tugenhua"
});

alert(person.name); // tugenhua
for (var i in person) {
  alert(person[i]); // 不會彈出
}

2. 存取器屬性

存取器屬性包含 getter 與 setter 函式:讀取時呼叫 getter,負責回傳有效值;寫入時呼叫 setter 並傳入新值,負責決定如何處理資料。它同樣有四個特性:configurable、enumerable,加上 get(讀取時呼叫,預設 undefined)與 set(寫入時呼叫,預設 undefined)。

var book = { _year: 2004, edit: 1 };

Object.defineProperty(book, "year", {
  get: function(){
    return this._year;
  },
  set: function(newValue) {
    if (newValue > 2004) {
      this._year = newValue;
      this.edit += newValue - 2004;
    }
  }
});

book.year = 2005;
alert(book.edit); // 2

先定義 book 物件並初始化 _year 與 edit,接著為它新增 year 屬性。因為 year 是存取器屬性,賦值時先觸發 set,把 2005 傳給 newValue,於是 this._year 等於 2005、this.edit 等於 2。

支援 Object.defineProperty 的瀏覽器有 IE9+、Firefox 4+、Safari 5+、Chrome 與 Opera 12+。

七、定義多個屬性與讀取描述符

ECMAScript 5 另外提供了 Object.defineProperties(),可以一次定義多個屬性。它接收兩個參數:第一個是要添加或修改屬性的物件,第二個物件的屬性需與前者要處理的屬性一一對應。

var book = { _year: 2004, edit: 1 };

Object.defineProperties(book, {
  _year: { value: 2015 },
  edit:  { value: 2 },
  year: {
    get: function(){
      return this._year;
    },
    set: function(newValue){
      if (newValue > this._year) {
        this._year = newValue;
        this.edit += newValue - this._year;
      }
    }
  }
});

這裡設定了三個屬性,前兩個會覆蓋 book 原有的值,第三個則是新增。

那要怎麼讀回屬性的描述符?ECMAScript 5 提供了 Object.getOwnPropertyDescriptor(),接收物件與屬性名稱兩個參數。回傳值也是一個物件:若是存取器屬性,包含 configurable、enumerable、get 與 set;若是資料屬性,則包含 configurable、enumerable、writable 與 value。

var descriptor = Object.getOwnPropertyDescriptor(book, "_year");
console.log(descriptor);

印出的結果是:

Object {value: 2015, writable: true, enumerable: true, configurable: true}

現在 value 已經是 2015 了。若換成存取器屬性:

var descriptor = Object.getOwnPropertyDescriptor(book, "year");
console.log(descriptor);

印出如下:

就是前面提到的那四個特性。支援 Object.getOwnPropertyDescriptor 的瀏覽器有 IE9+、Firefox 4+、Safari 5+、Opera 12+ 與 Chrome。

八、理解建構函式

function Dog(name, age) {
  this.name = name;
  this.age = age;
  this.say = function(){
    alert(this.name);
  }
}

這就是一個建構函式,它與普通函式的差異有兩點:

1. 函式名稱的第一個字母慣例上大寫,用來區別它是建構函式;
2. 初始化時必須用 new。嚴格來說,任何函式只要透過 new 呼叫,就能當成建構函式使用。

var dog1 = new Dog("wangwang1", '10');
var dog2 = new Dog("wangwang2", '11');

此時 dog1.say() 印出 wangwang1、dog2.say() 印出 wangwang2。dog1 與 dog2 各自保存 Dog 的一個不同實例,且兩者都有一個 constructor 屬性指向 Dog:

alert(dog1.constructor === Dog); // true
alert(dog2.constructor === Dog); // true

同時,實例化出來的物件都是 Object 的實例,可以用 instanceof 檢測:

alert(dog1 instanceof Object); // true
alert(dog2 instanceof Object); // true
alert(dog1 instanceof Dog);    // true
alert(dog2 instanceof Dog);    // true

建構函式的缺點是:每個方法都要在每個實例上重新建立一次。上面 dog1 與 dog2 雖然都有 say 方法,但彼此並非同一個 Function 實例:

alert(dog1.say === dog2.say); // false

因此需要引入原型模式來解決共享問題。我們建立的每個函式都有一個 prototype 屬性,它是一個指標,指向一個物件,而這個物件的用途就是讓所有實例共享屬性與方法:

function Dog() {};

Dog.prototype = {
  name: 'wangwang',
  age: '11',
  say: function(){
    alert(this.name); // wangwang
  }
}

var dog1 = new Dog();
dog1.say();

var dog2 = new Dog();
dog2.say();

alert(dog1.say === dog2.say); // true

九、原型物件與屬性查找

不管什麼時候,只要建立一個函式,就會依一組特定規則為它建立 prototype 屬性,指向該函式的原型物件。以 Dog 為例,就會有 Dog.prototype 這個物件;預設情況下,所有原型物件都會自動獲得一個 constructor 屬性。

建構函式的任何一個實例,都會有一個內部指標指向該建構函式的原型。要確認這種關係,可以使用 isPrototypeOf():

function Dog() {};

Dog.prototype = {
  constructor: Dog,
  name: 'wangwang',
  age: '11',
  say: function(){
    alert(this.name); // wangwang
  }
}

var dog1 = new Dog();
var dog2 = new Dog();

console.log(Dog.prototype.isPrototypeOf(dog1)); // true
console.log(Dog.prototype.isPrototypeOf(dog2)); // true

ECMAScript 5 新增了 Object.getPrototypeOf(),可以直接取得原型:

console.log(Object.getPrototypeOf(dog1) === Dog.prototype); // true
console.log(Object.getPrototypeOf(dog1).name);              // wangwang

在用原型實作繼承時,這個方法非常重要。支援的瀏覽器有 IE9+、Firefox 3.5+、Safari 5+、Opera 12+ 與 Chrome。

屬性查找規則:每當讀取某個物件的某個屬性時,都會執行一次搜尋,目標是具有該名稱的屬性。搜尋先從物件實例本身開始,找到就回傳;找不到才沿著指標搜尋原型物件;原型也沒有,最終回傳 undefined。

雖然可以透過實例讀取原型中的值,卻不能透過實例改寫原型中的值。如果在實例上新增一個與原型同名的屬性,那只是在實例上建立該屬性,它會遮蔽(shadow)原型中的同名屬性:

var dog1 = new Dog();
var dog2 = new Dog();

dog1.name = "aa";
console.log(dog1.name); // aa
console.log(dog2.name); // wangwang

dog1 查找時命中實例自身的 name,dog2 則仍查找原型上的 name。若想讓 dog1 重新查找原型,可以用 delete 刪除實例屬性:

delete dog1.name;
console.log(dog1.name); // wangwang

要判斷屬性是存在實例還是原型,則可使用 hasOwnProperty():

var dog1 = new Dog();
var dog2 = new Dog();

console.log(dog1.hasOwnProperty("name")); // false

dog1.name = "aa";
console.log(dog1.name);                   // aa
console.log(dog1.hasOwnProperty("name"));  // true
console.log(dog2.name);                   // wangwang
console.log(dog2.hasOwnProperty("name"));  // false

delete dog1.name;
console.log(dog1.name);                   // wangwang
console.log(dog1.hasOwnProperty("name"));  // false

十、原型與 in 操作符

in 操作符有兩種用法:單獨使用,或放在 for-in 迴圈中。單獨使用時,只要物件能存取到該屬性就回傳 true,不論它在實例還是原型中:

var dog1 = new Dog();
console.log("name" in dog1); // true

dog1.name = "aa";
console.log("name" in dog1); // true

把 in 與 hasOwnProperty 組合起來,就能判斷屬性是否位於原型上:in 一律為 true,hasOwnProperty 只在實例中為 true,取反後兩者皆成立即代表在原型上:

function hasPrototypeProperty(object, attr){
  return !object.hasOwnProperty(attr) && (attr in object);
}

測試一下:

var dog1 = new Dog();

console.log(hasPrototypeProperty(dog1, 'name')); // true,在原型中

dog1.name = 'aa';
console.log(hasPrototypeProperty(dog1, 'name')); // false,在實例中

十一、for-in 與屬性枚舉

使用 for-in 迴圈時,回傳的是所有能透過物件存取、且可枚舉的屬性,其中既包含實例屬性,也包含原型屬性。這裡有個 IE 歷史遺留問題:如果在 IE8 及以下環境中,實例遮蔽了原型中已有的同名方法,該屬性不會在 for-in 中出現:

var obj = {
  toString: function(){
    return "aa";
  }
};

for (var i in obj){
  if (i == "toString") {
    alert(1);
  }
}

把 toString 改成 toString22 就能在 IE 下彈出提示,否則毫無反應。原因在於 IE 的實作把原型的 toString() 標記為 [[Enumerable]] 為 false,因此即使被實例遮蔽,仍會被跳過。

若要取得物件上所有可枚舉的實例屬性,可使用 ECMAScript 5 的 Object.keys(),它接收一個物件,回傳包含所有可枚舉屬性的字串陣列:

var dog1 = new Dog();
var keys = Object.keys(Dog.prototype);
console.log(keys); // ["name", "age", "say"]

keys 的順序與 for-in 出現的順序一致。若想取得所有實例屬性(不論是否可枚舉),則改用 Object.getOwnPropertyNames():

var keys = Object.getOwnPropertyNames(Dog.prototype);
console.log(keys); // ["name", "age", "say"]

這兩個方法都可以用來替代 for-in 迴圈,支援的瀏覽器有 IE9+、Firefox 4+、Safari 5+、Opera 12+ 與 Chrome。

十二、constructor 為什麼會「跑掉」

var dog1 = new Dog();

console.log(dog1 instanceof Object);      // true
console.log(dog1 instanceof Dog);         // true
console.log(dog1.constructor == Dog);     // false
console.log(dog1.constructor == Object);  // true

第三行為何是 false?因為每建立一個函式,就會同時建立它的 prototype 物件,這個物件會自動獲得 constructor 屬性。但我們用物件字面量重新指派 Dog.prototype 時,等於是用新物件覆寫了整個原型,constructor 也就變成新物件的 constructor(即 Object),不再指向 Dog。

若希望它仍指向 Dog,可以在原型中明確補上:

Dog.prototype = {
  constructor: Dog,
  name: 'wangwang',
  age: '11',
  say: function(){
    alert(this.name); // wangwang
  }
};

var dog1 = new Dog();
console.log(dog1.constructor == Dog); // true

十三、原型的動態性

function Dog() {};

var dog1 = new Dog();

Dog.prototype.say = function(){
  alert(1);
};

dog1.say(); // 1

先實例化,再為原型添加 say 方法,之後透過實例依然呼叫得到。原因是實例並沒有複製原型,而是持有指向原型的指標,查找時找不到才往原型走。這也說明了為何後加的屬性能被既有實例看到。

不過,如果是整體重寫原型,情況就不同了:

function Dog() {};

var dog1 = new Dog();

Dog.prototype = {
  constructor: 'Dog',
  name: 'dog',
  age: '1',
  say: function(){
    alert(this.age);
  }
};

dog1.say(); // 報錯

實例化時建立的指標指向的是「當時那個原型物件」,一旦原型被整體替換,舊實例就與新原型切斷了關係,自然找不到方法。若在重寫之後才實例化,就一切正常:

// dog1.say();      // 報錯
var dog2 = new Dog();
dog2.say();          // 1

十四、原型重寫造成的分裂

原型重寫會改變既有實例的指標指向,也就是說舊原型被廢棄了。這帶來一個後果:同一個建構器可以產出兩批行為不同的實例。

function MyObject(){};

var obj1 = new MyObject();

MyObject.prototype.type  = 'myObject';
MyObject.prototype.value = "aa";

var obj2 = new MyObject();

MyObject.prototype = {
  constructor: 'MyObject',
  type: 'Brid',
  value: 'bb'
};

var obj3 = new MyObject();

// 顯示物件的屬性
alert(obj1.type); // myObject
alert(obj2.type); // myObject
alert(obj3.type); // Brid

obj1 與 obj2 指向同一個(舊)原型,obj3 則指向重寫後的新原型。連帶造成 instanceof 的判斷結果:

alert(obj1 instanceof MyObject); // false
alert(obj2 instanceof MyObject); // false
alert(obj3 instanceof MyObject); // true

看到這裡可能會疑惑:obj1 與 obj2 明明是用 MyObject 實例化出來的,為什麼不是 MyObject 的實例?再看 constructor:

console.log(obj1 instanceof obj1.constructor); // false
console.log(obj1.constructor === MyObject);    // true

第一行 false 說明 obj1 並不是 obj1.constructor 所指建構器的實例;第二行 true 說明 obj1.constructor 仍指向 MyObject。兩者結合起來,結論就是:obj1 不是 MyObject 的實例。

歸納一下,在 JavaScript 中,一個建構器的原型可以被重寫,這意味著舊原型被廢棄:

1. 舊實例仍使用被廢棄的原型,並受其影響;
2. 新建的實例使用重寫後的原型,受新原型影響。

十五、建構器重寫

與原型重寫相對的是建構器本身被重寫:

function MyObject(){};

var obj1 = new MyObject();

MyObject = function(){};

var obj2 = new MyObject();

console.log(obj1 instanceof MyObject);            // false
console.log(obj2 instanceof MyObject);            // true
console.log(obj1 instanceof obj1.constructor);    // true

obj1 實例化之後,MyObject 被下面的函式表達式覆蓋了,所以 obj1 不是新 MyObject 的實例,obj2 才是。而 obj1 仍舊是 obj1.constructor 的實例,說明建構器重寫不會影響既有實例的繼承關係。

如果改成具名函式宣告:

function MyObject(){};

var obj1 = new MyObject();

function MyObject(){};

var obj2 = new MyObject();

console.log(obj1 instanceof MyObject);         // true
console.log(obj2 instanceof MyObject);         // true
console.log(obj1 instanceof obj1.constructor); // true

從程式碼結構看,obj1 與 obj2 分別來自兩個不同的 MyObject 建構器;但由於函式宣告會被提升(hoisting),後者其實覆蓋了前者,所以兩者都是第二個 MyObject 的實例,三個判斷全部為 true。

十六、原型模式的兩個缺點

1. 省略了建構函式傳遞參數,所有實例預設都取得相同的屬性值與方法。若希望 A 實例有自己的屬性、B 實例又有另一組,原型模式無法滿足;
2. 共享是優點也是缺點。若在 A 實例上添加方法,由於原型共用,B 實例也會跟著擁有。

function Dog(){};

Dog.prototype = {
  constructor: Dog,
  name: 'aa',
  values: ["aa", 'bb'],
  say: function(){
    alert(this.name);
  }
};

var dog1 = new Dog();
dog1.values.push("cc");
console.log(dog1.values); // ["aa","bb","cc"]

var dog2 = new Dog();
console.log(dog2.values); // ["aa","bb","cc"]

給 dog1 的 values 推入 cc 之後,原型上的陣列就變成了 ["aa","bb","cc"],之後實例化的 dog2 自然也拿到同樣的內容。這類引用型別放在原型上的問題,是原型模式最典型的陷阱。

十七、組合使用建構函式模式與原型模式

最常見的解法是兩者搭配:用建構函式定義實例私有屬性,用原型定義共享的屬性與方法。這樣既節省記憶體,又能讓每個實例擁有自己的資料,是實務上使用最廣的模式。

function Dog(name, age){
  this.name = name;
  this.age = age;
  this.values = ["aa", 'bb'];
};

Dog.prototype = {
  constructor: Dog,
  say: function(){
    alert(this.name);
  }
};

var dog1 = new Dog("dog1", '12');
dog1.values.push("cc");
console.log(dog1.values); // ["aa","bb","cc"]

var dog2 = new Dog("dog2", '14');
console.log(dog2.values); // ["aa","bb"]

console.log(dog1.values === dog2.values); // false
console.log(dog1.say === dog2.say);         // true

values 各自獨立(false),say 共用同一個函式(true),正是我們想要的效果。除此之外還有多種變形模式,這裡不逐一展開,有興趣可以參考《JavaScript 設計模式》。

十八、原型鏈:最經典的繼承方式

ECMAScript 把原型鏈作為繼承的主要方法,其核心思想是讓一個引用型別去繼承另一個引用型別的屬性與方法。

回顧一下關係:每個建構函式都有一個原型物件,原型物件包含一個指向建構函式的指標,而實例包含一個指向原型的內部指標。如果我們讓某個原型物件等於另一個型別的實例,那麼這個原型就包含了指向另一個型別的指標,另一個原型裡又有指向它自己建構函式的指標——層層遞進,就形成了原型鏈。

function Animal() {
  this.name = "aa";
}

Animal.prototype.fly = function(){
  return this.name;
};

function Dog() {
  this.value = "bb";
}

Dog.prototype = new Animal();

Dog.prototype.fly = function(){
  return this.name;
};

var dog1 = new Dog();
console.log(dog1.fly()); // aa

先定義 Animal,它有 name 屬性與原型方法 fly;接著定義 Dog,並讓 Dog.prototype = new Animal(),Dog 就繼承了 Animal 的所有屬性與方法。之後 Dog 定義自己的 fly,覆寫了 Animal 的版本,但 this.name 仍解析到 Animal 設定的 "aa",因此印出 aa。

換句話說,若 A 要繼承 B,寫法就是:

A.prototype = new B();

再看看 dog1 與兩個建構器的關係:

console.log(dog1 instanceof Dog);             // true
console.log(dog1 instanceof Animal);          // true
console.log(dog1 instanceof dog1.constructor); // true
console.log(dog1.constructor === Dog);         // false
console.log(dog1.constructor === Animal);      // true

dog1 同時是 Dog 與 Animal 的實例,但 constructor 已經被重寫,指向了 Animal。

呼叫 dog1.fly() 時,查找順序是:先在實例上找 → 再到 Dog.prototype → 接著 Animal.prototype → 最後是 Object.prototype。所有函式預設的原型都繼承自 Object,這也是所有自訂型別天生擁有 toString() 與 valueOf() 的原因:

console.log(dog1 instanceof Object); // true

除了 instanceof,也可以用 isPrototypeOf 檢測原型與實例的關係:

console.log(Object.prototype.isPrototypeOf(dog1)); // true
console.log(Dog.prototype.isPrototypeOf(dog1));    // true
console.log(Animal.prototype.isPrototypeOf(dog1)); // true

使用原型鏈時要注意兩點:

1. 子型別若需重寫或新增方法,一定要放在替換原型之後,否則會被覆蓋掉:

function Animal() {
  this.name = "aa";
}
Animal.prototype.fly = function(){
  return this.name;
};

function Dog() {
  this.value = "bb";
}

// 繼承 Animal
Dog.prototype = new Animal();

// 重寫原型的方法
Dog.prototype.fly = function(){
  return this.name;
};

// 給自身添加新方法
Dog.prototype.cry = function(){
  return false;
};

var dog1 = new Dog();
console.log(dog1.fly()); // aa
console.log(dog1.cry()); // false

2. 繼承之後不能再用物件字面量建立原型方法,因為那等於再次重寫原型,會切斷原型鏈:

Dog.prototype = new Animal();

Dog.prototype = {
  fly: function(){
    return this.name;
  },
  cry: function(){
    return false;
  }
};

var dog1 = new Dog();
console.log(dog1.fly());              // undefined
console.log(dog1 instanceof Animal);  // false

印出 undefined 與 false,正說明了與 Animal 的連結已被切斷,fly 自然也繼承不到。

原型鏈的兩個缺點:

1. 原型上的所有屬性與方法會被所有實例共享,引用型別尤其危險:

function Animal() {
  this.values = ["aa", 'bb'];
}

function Dog(){};

Dog.prototype = new Animal();

var dog1 = new Dog();
dog1.values.push("cc");
console.log(dog1.values); // ["aa","bb","cc"]

var dog2 = new Dog();
console.log(dog2.values); // ["aa","bb","cc"]

2. 建立子型別實例時,無法向超型別的建構函式傳遞參數。

十九、借用建構函式

針對上述兩點,可以在子型別建構函式內部呼叫超型別的建構函式,透過 call 或 apply 實現:

function Animal() {
  this.values = ["aa", 'bb'];
}

function Dog(){
  // Dog 繼承於 Animal
  Animal.call(this);
};

var dog1 = new Dog();
dog1.values.push("cc");
console.log(dog1.values); // ['aa','bb','cc']

var dog2 = new Dog();
console.log(dog2.values); // ['aa','bb']

這樣每個實例都有自己的 values 副本,互不干擾。參數也能照傳:

function Animal(name) {
  this.values = ["aa", 'bb'];
  this.name = name;
}

function Dog(){
  // Dog 繼承於 Animal
  Animal.call(this, "dog22");
  this.age = 22;
};

var dog1 = new Dog();
console.log(dog1.name); // dog22
console.log(dog1.age);  // 22

借用建構函式的缺點:

1. 方法無法復用,每次都要在建構函式中重新定義;
2. 在超型別原型上定義的屬性與方法,子型別完全看不到,結果所有型別都被迫只能使用建構函式模式。

二十、組合繼承

為了解決這兩個問題,可以把兩種模式結合起來,這就是組合繼承:用原型鏈繼承原型上的屬性與方法,用借用建構函式繼承實例屬性。如此一來,方法得以復用,每個實例又能擁有自己的資料。

function Animal(name) {
  this.values = ["aa", 'bb'];
  this.name = name;
}

Animal.prototype.sayName = function(){
  return this.name;
};

function Dog(name, age){
  // Dog 繼承屬性
  Animal.call(this, name);
  this.age = age;
};

// 繼承方法
Dog.prototype = new Animal();
Dog.prototype.constructor = Dog;
Dog.prototype.sayAge = function(){
  return this.age;
};

var dog1 = new Dog("dog111", '12');
dog1.values.push("cc");
console.log(dog1.values);    // ['aa','bb','cc']
console.log(dog1.sayAge());  // 12
console.log(dog1.sayName()); // dog111

var dog2 = new Dog("dog222", '14');
console.log(dog2.values);    // ['aa','bb']
console.log(dog2.sayAge());  // 14
console.log(dog2.sayName()); // dog222

Animal 定義了 name 與 values 兩個屬性,原型上有 sayName 方法;Dog 透過 Animal.call(this, name) 繼承屬性並傳入參數,又透過 Dog.prototype = new Animal() 繼承方法。這樣一來,不同實例各有自己的屬性,同時共享方法,也節省了記憶體。

別忘了補回 constructor 指標:

Dog.prototype.constructor = Dog;

這樣 dog1.constructor === Dog 才會是 true;若把這行註釋掉,就會回傳 false。

二十一、原型式繼承

原型式繼承的思想是:建立一個臨時建構函式,把傳入的物件作為它的原型,最後回傳這個臨時建構函式的新實例:

function object(obj) {
  function F() {};
  F.prototype = obj;
  return new F();
}

實際應用:

var person = {
  name: 'aa',
  firends: ['zhangsan', 'lisi', 'wangwu']
};

var anthorperson = object(person);
anthorperson.name = "bb";
anthorperson.firends.push("zhaoliu");

var aperson2 = object(person);
aperson2.name = 'cc';
aperson2.firends.push("longen");

console.log(person.firends);
// ["zhangsan", "lisi", "wangwu", "zhaoliu", "longen"]

注意 firends 陣列被兩個新物件共同改動了——這正是原型式繼承沿用「共享原型」所帶來的副作用。

這種模式的前提是必須有一個物件作為另一個物件的基礎,若手上有這樣的物件,傳進 object() 即可。

ECMAScript 5 用 Object.create() 規範了原型式繼承,它接收兩個參數:第一個是作為新物件原型的物件,第二個可選,用來為新物件定義額外屬性。

var person = {
  name: 'aa',
  firends: ['zhangsan', 'lisi', 'wangwu']
};

var anthorperson = Object.create(person);
anthorperson.name = "bb";
anthorperson.firends.push("zhaoliu");

var bperson = Object.create(person);
bperson.name = 'longen';
bperson.firends.push("longen");

console.log(person.firends);
// ["zhangsan", "lisi", "wangwu", "zhaoliu", "longen"]

第二個參數的格式與 Object.defineProperties() 的第二個參數相同:每個屬性都透過自己的描述符定義,且會覆蓋原型物件上的同名屬性。

var anthorperson = Object.create(person, {
  name: { value: 'bb' }
});

console.log(anthorperson.name); // bb

支援 Object.create() 的瀏覽器有 IE9+、Firefox 4+、Safari 5+、Opera 12+ 與 Chrome。

二十二、寄生組合式繼承

組合繼承是 JavaScript 最常用的繼承模式,但它有一個明顯缺點:會呼叫兩次超型別的建構函式。第一次在繼承屬性時(Animal.call(this, name)),第二次在繼承方法時(Dog.prototype = new Animal())。第二次執行會在新物件上重新建立 name 與 values,把第一次繼承來的屬性覆蓋掉,顯然是浪費。

function Animal(name) {
  this.values = ["aa", 'bb'];
  this.name = name;
}

Animal.prototype.sayName = function(){
  return this.name;
};

function Dog(name, age){
  Animal.call(this, name);
  this.age = age;
};

Dog.prototype = new Animal();
Dog.prototype.constructor = Dog;
Dog.prototype.sayAge = function(){
  return this.age;
}

寄生組合式繼承的思路是:用借用建構函式繼承屬性,用原型鏈的混成形式繼承方法。本質上是先用寄生式繼承複製一份超型別的原型,再把結果指派給子型別的原型。基本模式如下:

function inheritPrototype(Dog, Animal) {
  var prototype = object(Animal.prototype);
  prototype.constructor = Dog;
  Dog.prototype = prototype;
}

這個函式接收子型別與超型別兩個建構函式:第一步建立一份超型別原型的副本;第二步為副本補上 constructor 屬性,彌補因重寫原型而失去的預設 constructor;最後把副本指派給子型別的原型。

完整範例:

function object(obj) {
  function F() {};
  F.prototype = obj;
  return new F();
}

function inheritPrototype(Dog, Animal) {
  var prototype = object(Animal.prototype);
  prototype.constructor = Dog;
  Dog.prototype = prototype;
}

function Animal(name) {
  this.values = ["aa", 'bb'];
  this.name = name;
}

Animal.prototype.sayName = function(){
  return this.name;
};

function Dog(name, age){
  // Dog 繼承屬性
  Animal.call(this, name);
  this.age = age;
};

inheritPrototype(Dog, Animal);

var dog1 = new Dog("wangwang", 12);
dog1.values.push("cc");
console.log(dog1.sayName()); // wangwang
console.log(dog1.values);    // ["aa", "bb", "cc"]

var dog2 = new Dog("ww2", 14);
console.log(dog2.sayName()); // ww2
console.log(dog2.values);    // ["aa", "bb"]

使用寄生組合式繼承,超型別的建構函式只被呼叫了一次——這正是它相較組合繼承的核心優勢,也是目前公認最理想的繼承實作方式。

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