DIV CSS 佈局教程網

透透徹徹理解 JavaScript 的動態語言特性
編輯:JavaScript綜合知識     

JavaScript 是一種直譯式語言,無法編譯成二進位檔。本文從 eval() 的動態執行、閉包概念,一路談到 call/apply、物件屬性描述、建構函式與原型,最後說明各種繼承模式,是理解 JS 動態本質的重要一篇。

動態執行與閉包

eval() 會把一段文字當成程式碼,在當前上下文中執行。它同時存在「全域閉包」與「當前函式閉包」兩種情境:

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

因為 eval 作用於函式內的區塊,改的是區域變數 i,外部的全域 i 依舊是 100。標準瀏覽器與 IE 在 window.eval() 的行為上並不一致,這是因為不同 JS 引擎對 eval 閉包環境的理解不同。IE 中可用 window.execScript() 讓程式碼永遠在全域閉包中執行。

要特別注意,eval 會把大括號視為複合語句標記,因此直接傳入物件字面量會報錯,需外加小括號使其成為表達式:

eval('({name:"MyName",value:1})'); // 回傳物件 Object {name: "MyName", value: 1}

常見應用是把伺服器返回的字串轉為物件:

var data = '{"name":"Mike","sex":"女","age":"29"}';
console.log(eval("("+data+")"));
// Object {name: "Mike", sex: "女", age: "29"}

此外 eval 與 with 都會改變作用域,使用時務必謹慎。

動態方法呼叫:call 與 apply

兩者都能動態呼叫函式並指定 this,差別在於第二個參數:call 逐一傳入,apply 則接收陣列或 arguments。

function foo(name){ alert("hi:"+name); }
foo.call(null,'longen');       // hi: longen
foo.apply(null,['tugenhua']);  // hi: tugenhua

透過 call/apply 改變 this 指向,可讓同一個函式在不同物件上執行:

function foo(){ alert(this.name); }
var obj1 = {name:'obj1'};
foo.call(obj1); // obj1

理解 JavaScript 物件

Object.defineProperty() 是 ECMAScript5 提供的方法,可精確控制屬性行為。ECMAScript 有兩種屬性:

1. 資料屬性,具備四個特性:

  • configurable:能否刪除或重新定義,預設 true。
  • enumerable:能否被 for-in 列舉,預設 true。
  • writable:能否修改值,預設 true。
  • value:屬性實際的資料值,預設 undefined。
var person = { name: 'longen' };
Object.defineProperty(person, "name", { writable: false, value: "tugenhua" });
person.name = "Greg";
alert(person.name); // tugenhua,無法修改

2. 訪問器屬性,透過 getter 與 setter 函式攔截讀寫:

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

若要一次定義多個屬性可用 Object.defineProperties();取得屬性描述符則用 Object.getOwnPropertyDescriptor()。

建構函式與原型

任何以 new 呼叫的函式都可當作建構函式,慣例是首字母大寫。每個建構函式實作出來的物件都有 constructor 屬性指向該建構函式,並可用 instanceof 檢測。

建構函式的缺點是每個方法都要在每個實例上重新建立,因此不同實例的同名方法並非同一個 Function:

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

原型模式正是為了解決資源的共享問題。每個函式都有一個 prototype 屬性,指向原型物件,供所有實例共享屬性與方法:

function Dog() {};
Dog.prototype = {
  constructor: Dog,
  name: 'wangwang',
  say: function(){ alert(this.name); }
};
var dog1 = new Dog();
var dog2 = new Dog();
alert(dog1.say === dog2.say); // true,共享同一個方法

讀取屬性時會先搜尋實例本身,找不到再往原型搜尋。若在實例上建立與原型同名的屬性,會屏蔽原型的屬性;用 delete 刪除實例屬性後,又能重新讀取原型的值。hasOwnProperty() 可判斷屬性是否存在於實例中,in 操作符則不分公司在實例或原型。

要取得所有可列舉的實例屬性可用 Object.keys(),要取得所有自身屬性(不論是否可列舉)則用 Object.getOwnPropertyNames()。

原型的動態性與重寫

為原型新增屬性或方法後,既有的實例也能立即生效,因為實例會回溯到原型搜尋。但若「整個重寫」原型,則會切斷既有實例與原型的連結:

function Dog() {};
var dog1 = new Dog();
Dog.prototype = { say: function(){ alert(1); } };
// dog1.say(); // 報錯,因為 dog1 仍指向舊原型

重寫原型時,务必記得補回 constructor 屬性,否則它會指向 Object 而非原本的建構函式。原型重寫後,舊實例受舊原型影響,新實例則受新原型影響。

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

最常見的做法是:用建構函式定義實例私有屬性,用原型定義共享方法,兼顧彈性與效能:

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");
var dog2 = new Dog("dog2",'14');
console.log(dog1.values === dog2.values); // false,各自獨立
console.log(dog1.say === dog2.say);       // true,共享方法

繼承的各種實作

原型鏈:讓子類型原型等於超類型的實例,是 ECMAScript 最主要的繼承方式。

function Animal() { this.name = "aa"; }
Animal.prototype.fly = function(){ return this.name; };
function Dog() { this.value = "bb"; }
Dog.prototype = new Animal();
var dog1 = new Dog();
console.log(dog1.fly()); // aa

注意:為原型添加方法一定要放在替換原型之後;且不能用物件字面量建立原型方法,否則會切斷原型鏈。原型鏈的缺點是屬性會被所有實例共享,且無法向超類型建構函式傳參。

借用建構函式:在子類型內部呼叫超類型建構函式,可避免共享問題並支援傳參:

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

缺點是無法複用原型方法,超類型的方法在子類型中不可見。

組合繼承:用原型鏈繼承方法、用借用建構函式繼承屬性,是最常用的模式:

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; }

原型式繼承:建立臨時建構函式,將傳入物件作為其原型並回傳新實例。ECMAScript5 的 Object.create() 將此模式標準化。

寄生組合式繼承:透過借用建構函式繼承屬性,透過原型鏈的混成形式繼承方法,只需呼叫一次超類型建構函式,是當前公認最理想的繼承模式:

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

掌握這些動態特性與繼承模式,才能真正寫出結構清晰、易於維護的 JavaScript 程式。

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