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 都會改變作用域,使用時務必謹慎。
兩者都能動態呼叫函式並指定 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
Object.defineProperty() 是 ECMAScript5 提供的方法,可精確控制屬性行為。ECMAScript 有兩種屬性:
1. 資料屬性,具備四個特性:
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 程式。