緊接上一篇,我們繼續深入探討 JavaScript 的面向對象機制。
除了字面式聲明(literal notation)之外,ECMAScript 還允許通過構造器(constructor)來創建對象。每個構造器本質上就是一個函數(function)對象,它含有一個名為 prototype 的屬性,用於實現基於原型的繼承(prototype-based inheritance)與共享屬性(shared properties)。對象可以通過「new 關鍵字 + 構造器調用」的方式創建,如下例:
// 構造器 Person 本身是一個函數對象
function Person() {
// 此處可做一些初始化工作
}
// 它有一個名叫 prototype 的屬性
Person.prototype = {
name: "張三",
age: 26,
gender: "男",
eat: function( stuff ) {
alert( "我在吃" + stuff );
}
}
// 使用 new 關鍵字構造對象
var p = new Person();
當年 JavaScript 的創造者為了讓這門語言與大名鼎鼎的 Java 沾上點關係(盡管如今大家都知道二者是「雷鋒和雷鋒塔」的關係),借用了 new 關鍵字來限定構造器調用,讓它在語法上看上去和 Java 創建對象的方式頗為相似。但要強調的是,這兩門語言中 new 的含義毫無關聯,因為它們構造對象的機理完全不同。也正是因為這種表面上的相似,許多習慣了類式面向對象的開發者難以透徹理解 JS 的原型構造方式——他們總是糾結於「為什麼函數名可以當類名用」。實質上,ECMAScript 這裡僅僅是借用了 new 這個關鍵字而已,換句話說,它完全可以用其他非 new 表達式來調用構造器創建對象。
在 ECMAScript 中,每個由構造器創建的對象都持有一個指向構造器 prototype 屬性值的隱式引用(implicit reference),這個引用被稱為原型(prototype)。進一步地,每個原型又可以擁有指向自身原型的隱式引用,如此層層遞進,便構成了所謂的原型鏈(prototype chain)。在具體的語言實現中,每個對象都有一個 __proto__ 屬性來實現對原型的隱式引用:
function Person( name ) {
this.name = name;
}
var p = new Person();
// 對象的隱式引用指向了構造器的 prototype 屬性,所以此處打印 true
console.log( p.__proto__ === Person.prototype );
// 原型本身是一個 Object 對象,所以他的隱式引用指向了
// Object 構造器的 prototype 屬性,故而打印 true
console.log( Person.prototype.__proto__ === Object.prototype );
// 構造器 Person 本身是一個函數對象,所以此處打印 true
console.log( Person.__proto__ === Function.prototype );
有了原型鏈,就能定義一種「屬性隱藏機制」,並借助它實現繼承。ECMAScript 規定:當給某個對象的屬性賦值時,解釋器會查找該對象原型鏈中第一個含有該屬性的對象並進行賦值;反之,獲取屬性值時,解釋器自然返回原型鏈中第一個具備該屬性的對象的屬性值。下圖說明了這種隱藏機制:
上圖中,object1->prototype1->prototype2 構成了對象 object1 的原型鏈。依據屬性隱藏機制可以清楚看到,prototype1 中的 property4 屬性和 prototype2 中的 property3 屬性都被隱藏了。理解了原型鏈,再來看 JS 中基於原型的繼承就輕鬆多了。下面是一個利用原型鏈實現繼承的簡單例子:
// 聲明 Animal 對象構造器
function Animal() {
}
// 將 Animal 的 prototype 屬性指向一個對象,
// 亦可直接理解為指定 Animal 對象的原型
Animal.prototype = {
name: animal",
weight: 0,
eat: function() {
alert( "Animal is eating!" );
}
}
// 聲明 Mammal 對象構造器
function Mammal() {
this.name = "mammal";
}
// 指定 Mammal 對象的原型為一個 Animal 對象。
// 實際上此處便是在創建 Mammal 對象和 Animal 對象之間的原型鏈
Mammal.prototype = new Animal();
// 聲明 Horse 對象構造器
function Horse( height, weight ) {
this.name = "horse";
this.height = height;
this.weight = weight;
}
// 將 Horse 對象的原型指定為一個 Mamal 對象,繼續構建 Horse 與 Mammal 之間的原型鏈
Horse.prototype = new Mammal();
// 重新指定 eat 方法,此方法將覆蓋從 Animal 原型繼承過來的 eat 方法
Horse.prototype.eat = function() {
alert( "Horse is eating grass!" );
}
// 驗證並理解原型鏈
var horse = new Horse( 100, 300 );
console.log( horse.__proto__ === Horse.prototype );
console.log( Horse.prototype.__proto__ === Mammal.prototype );
console.log( Mammal.prototype.__proto__ === Animal.prototype );
理解這段繼承邏輯的關鍵,就在於 Horse.prototype = new Mammal() 和 Mammal.prototype = new Animal() 這兩句。等號右邊會先構造出一個臨時對象,再將其賦值給左邊對象的 prototype 屬性,也就是把新建的對象作為左邊對象的原型。
從上面的代碼不難看出,基於原型的繼承雖然實現了代碼復用,但行文鬆散、可讀性欠佳,不利於擴展和源碼組織。不可否認,類式繼承在語言實現上更具健壯性,在構建可復用代碼和組織架構上也更具優勢。於是開發者們開始尋找一種能在 JavaScript 中以類式風格編碼的方法。
目前一些主流 JS 框架都提供了這類轉換機制,比如 Dojo 的 declare()、Ext 的 extend() 等。而在眾多框架問世之前,JavaScript 大師 Douglas Crockford 最早利用三個函數對 Function 對象進行擴展,實現了這種轉換;此外還有 Dean Edwards 實現的著名 Base.js。值得一提的是,jQuery 之父 John Resig 博眾家之長,用不到 30 行代碼便實現了自己的 Simple Inheritance:
// 聲明 Person 類
var Person = Class.extend( {
_issleeping: true,
init: function( name ) {
this._name = name;
},
isSleeping: function() {
return this._issleeping;
}
} );
// 聲明 Programmer 類,並繼承 Person
var Programmer = Person.extend( {
init: function( name, issleeping ) {
// 調用父類構造函數
this._super( name );
// 設置自己的狀態
this._issleeping = issleeping;
}
} );
var person = new Person( "張三" );
var diors = new Programmer( "張江男", false );
// 打印 true
console.log( person.isSleeping() );
// 打印 false
console.log( diors.isSleeping() );
// 此處全為 true,故打印 true
console.log( person instanceof Person && person instanceof Class
&& diors instanceof Programmer &&
diors instanceof Person && diors instanceof Class );
只要你已充分理解原型、函數構造器、閉包以及基於上下文的 this,那麼理解 Simple Inheritance 的實現原理並不困難。本質上,var Person = Class.extend(...) 這句話中,左邊的 Person 拿到的其實是 Class 調用 extend 方法返回的一個構造器(也就是一個 function 對象)的引用。下圖是 Simple Inheritance 的源碼及逐行中文註釋:
如果說到這裡你仍對 JavaScript 的面向對象抱有懷疑,那多半是認為它沒有實現信息隱藏,即私有與公有之分。與其他類式語言顯式聲明私有公有不同,JavaScript 的信息隱藏是靠閉包實現的:
// 聲明 User 構造器
function User( pwd ) {
// 定義私有屬性
var password = pwd;
// 定義私有方法
function getPassword() {
// 返回了閉包中的 password
return password;
}
// 特權函數聲明,用於該對象其他公有方法能通過該特權方法訪問到私有成員
this.passwordService = function() {
return getPassword();
}
}
// 公有成員聲明
User.prototype.checkPassword = function( pwd ) {
return this.passwordService() === pwd;
};
// 驗證隱藏性
var u = new User( "123456" );
// 打印 true
console.log( u.checkPassword( "123456" ) );
// 打印 undefined
console.log( u.password );
// 打印 true
console.log( typeof u.gePassword === "undefined" );
JavaScript 之所以必須依賴閉包來實現信息隱藏,是由其函數式語言特性所決定的。Douglas Crockford 在《Private members in JavaScript》一文中有更權威、更詳盡的介紹。
JavaScript 被稱為「世界上最被誤解的編程語言」,因為它身披 C 語言家族的外衣,骨子裡卻流淌著 LISP 風格的函數式血液;它沒有類,卻也徹底地實現了面向對象。要想真正吃透這門語言,就必須扒開它 C 語言的外殼,回到函數式編程的视角,同時放下原有的類式面向對象思維去重新領悟。隨著近年 Web 應用的普及以及 JS 語言自身的長足發展,特別是後端 JS 引擎(如基於 V8 的 Node.js)的出現,可以預見,曾經只是用來編寫頁面小效果的 JavaScript,將迎來更廣闊的天地。這樣的趨勢,也對 JS 開發者提出了更高的要求——唯有真正領悟這門語言,才能在大型項目中釋放出它的威力。