|
|
注：本章中的jClass的實現(xiàn)參考了Simple JavaScript Inheritance的做法。
首先讓我們來回顧一下第一章中介紹的例子：
function Person(name) {
this.name = name;
}
Person.prototype = {
getName: function() {
return this.name;
}
}
function Employee(name, employeeID) {
this.name = name;
this.employeeID = employeeID;
}
Employee.prototype = new Person();
Employee.prototype.getEmployeeID = function() {
return this.employeeID;
};
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.getName()); // "ZhangSan"
修正constructor的指向錯誤
從上一篇文章中關(guān)于constructor的描述，我們知道Employee實例的constructor會有一個指向錯誤，如下所示：
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.constructor === Employee); // false
console.log(zhang.constructor === Object); // true
我們需要簡單的修正： function Employee(name, employeeID) {
this.name = name;
this.employeeID = employeeID;
}
Employee.prototype = new Person();
Employee.prototype.constructor = Employee;
Employee.prototype.getEmployeeID = function() {
return this.employeeID;
};
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.constructor === Employee); // true
console.log(zhang.constructor === Object); // false
創(chuàng)建Employee類時實例化Person是不合適的
但另一方面，我們又必須依賴于這種機制來實現(xiàn)繼承。 解決辦法是不在構(gòu)造函數(shù)中初始化數(shù)據(jù)，而是提供一個原型方法（比如init）來初始化數(shù)據(jù)。
// 空的構(gòu)造函數(shù)這種方式下，必須在實例化一個對象后手工調(diào)用init函數(shù)，如下：
function Person() {
}
Person.prototype = {
init: function(name) {
this.name = name;
},
getName: function() {
return this.name;
}
}
// 空的構(gòu)造函數(shù)
function Employee() {
}
// 創(chuàng)建類的階段不會初始化父類的數(shù)據(jù)，因為Person是一個空的構(gòu)造函數(shù)
Employee.prototype = new Person();
Employee.prototype.constructor = Employee;
Employee.prototype.init = function(name, employeeID) {
this.name = name;
this.employeeID = employeeID;
};
Employee.prototype.getEmployeeID = function() {
return this.employeeID;
};
var zhang = new Employee();
zhang.init("ZhangSan", "1234");
console.log(zhang.getName()); // "ZhangSan"
如何自動調(diào)用init函數(shù)？
必須達到兩個效果，構(gòu)造類時不要調(diào)用init函數(shù)和實例化對象時自動調(diào)用init函數(shù)?？磥砦覀冃枰谡{(diào)用空的構(gòu)造函數(shù)時有一個狀態(tài)標示。
// 創(chuàng)建一個全局的狀態(tài)標示 - 當前是否處于類的構(gòu)造階段但是這樣就必須引入全局變量，這是一個不好的信號。
var initializing = false;
function Person() {
if (!initializing) {
this.init.apply(this, arguments);
}
}
Person.prototype = {
init: function(name) {
this.name = name;
},
getName: function() {
return this.name;
}
}
function Employee() {
if (!initializing) {
this.init.apply(this, arguments);
}
}
// 標示當前進入類的創(chuàng)建階段，不會調(diào)用init函數(shù)
initializing = true;
Employee.prototype = new Person();
Employee.prototype.constructor = Employee;
initializing = false;
Employee.prototype.init = function(name, employeeID) {
this.name = name;
this.employeeID = employeeID;
};
Employee.prototype.getEmployeeID = function() {
return this.employeeID;
};
// 初始化類實例時，自動調(diào)用類的原型函數(shù)init，并向init中傳遞參數(shù)
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.getName()); // "ZhangSan"
如何避免引入全局變量initializing？
我們需要引入一個全局的函數(shù)來簡化類的創(chuàng)建過程，同時封裝內(nèi)部細節(jié)避免引入全局變量。
// 當前是否處于創(chuàng)建類的階段使用jClass函數(shù)來創(chuàng)建類和繼承類的方法：
var initializing = false;
function jClass(baseClass, prop) {
// 只接受一個參數(shù)的情況 - jClass(prop)
if (typeof (baseClass) === "object") {
prop = baseClass;
baseClass = null;
}
// 本次調(diào)用所創(chuàng)建的類（構(gòu)造函數(shù)）
function F() {
// 如果當前處于實例化類的階段，則調(diào)用init原型函數(shù)
if (!initializing) {
this.init.apply(this, arguments);
}
}
// 如果此類需要從其它類擴展
if (baseClass) {
initializing = true;
F.prototype = new baseClass();
F.prototype.constructor = F;
initializing = false;
}
// 覆蓋父類的同名函數(shù)
for (var name in prop) {
if (prop.hasOwnProperty(name)) {
F.prototype[name] = prop[name];
}
}
return F;
};
var Person = jClass({
init: function(name) {
this.name = name;
},
getName: function() {
return this.name;
}
});
var Employee = jClass(Person, {
init: function(name, employeeID) {
this.name = name;
this.employeeID = employeeID;
},
getEmployeeID: function() {
return this.employeeID;
}
});
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.getName()); // "ZhangSan"
OK，現(xiàn)在創(chuàng)建類和實例化類的方式看起來優(yōu)雅多了。 但是這里面還存在明顯的瑕疵，Employee的初始化函數(shù)init無法調(diào)用父類的同名方法。
如何調(diào)用父類的同名方法？
我們可以通過為實例化對象提供一個base的屬性，來指向父類（構(gòu)造函數(shù)）的原型，如下：
// 當前是否處于創(chuàng)建類的階段調(diào)用方式：
var initializing = false;
function jClass(baseClass, prop) {
// 只接受一個參數(shù)的情況 - jClass(prop)
if (typeof (baseClass) === "object") {
prop = baseClass;
baseClass = null;
}
// 本次調(diào)用所創(chuàng)建的類（構(gòu)造函數(shù)）
function F() {
// 如果當前處于實例化類的階段，則調(diào)用init原型函數(shù)
if (!initializing) {
// 如果父類存在，則實例對象的base指向父類的原型
// 這就提供了在實例對象中調(diào)用父類方法的途徑
if (baseClass) {
this.base = baseClass.prototype;
}
this.init.apply(this, arguments);
}
}
// 如果此類需要從其它類擴展
if (baseClass) {
initializing = true;
F.prototype = new baseClass();
F.prototype.constructor = F;
initializing = false;
}
// 覆蓋父類的同名函數(shù)
for (var name in prop) {
if (prop.hasOwnProperty(name)) {
F.prototype[name] = prop[name];
}
}
return F;
};
var Person = jClass({
init: function(name) {
this.name = name;
},
getName: function() {
return this.name;
}
});
var Employee = jClass(Person, {
init: function(name, employeeID) {
// 調(diào)用父類的原型函數(shù)init，注意使用apply函數(shù)修改init的this指向
this.base.init.apply(this, [name]);
this.employeeID = employeeID;
},
getEmployeeID: function() {
return this.employeeID;
},
getName: function() {
// 調(diào)用父類的原型函數(shù)getName
return "Employee name: " + this.base.getName.apply(this);
}
});
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.getName()); // "Employee name: ZhangSan"
目前為止，我們已經(jīng)修正了在第一章手工實現(xiàn)繼承的種種弊端。 通過我們自定義的jClass函數(shù)來創(chuàng)建類和子類，通過原型方法init初始化數(shù)據(jù)， 通過實例屬性base來調(diào)用父類的原型函數(shù)。
唯一的缺憾是調(diào)用父類的代碼太長，并且不好理解， 如果能夠按照如下的方式調(diào)用豈不是更妙：
var Employee = jClass(Person, {
init: function(name, employeeID) {
// 如果能夠這樣調(diào)用，就再好不過了
this.base(name);
this.employeeID = employeeID;
}
});
優(yōu)化jClass函數(shù)
// 當前是否處于創(chuàng)建類的階段此時，創(chuàng)建類與子類以及調(diào)用方式都顯得非常優(yōu)雅，請看：
var initializing = false;
function jClass(baseClass, prop) {
// 只接受一個參數(shù)的情況 - jClass(prop)
if (typeof (baseClass) === "object") {
prop = baseClass;
baseClass = null;
}
// 本次調(diào)用所創(chuàng)建的類（構(gòu)造函數(shù)）
function F() {
// 如果當前處于實例化類的階段，則調(diào)用init原型函數(shù)
if (!initializing) {
// 如果父類存在，則實例對象的baseprototype指向父類的原型
// 這就提供了在實例對象中調(diào)用父類方法的途徑
if (baseClass) {
this.baseprototype = baseClass.prototype;
}
this.init.apply(this, arguments);
}
}
// 如果此類需要從其它類擴展
if (baseClass) {
initializing = true;
F.prototype = new baseClass();
F.prototype.constructor = F;
initializing = false;
}
// 覆蓋父類的同名函數(shù)
for (var name in prop) {
if (prop.hasOwnProperty(name)) {
// 如果此類繼承自父類baseClass并且父類原型中存在同名函數(shù)name
if (baseClass &&
typeof (prop[name]) === "function" &&
typeof (F.prototype[name]) === "function") {
// 重定義函數(shù)name -
// 首先在函數(shù)上下文設(shè)置this.base指向父類原型中的同名函數(shù)
// 然后調(diào)用函數(shù)prop[name]，返回函數(shù)結(jié)果
// 注意：這里的自執(zhí)行函數(shù)創(chuàng)建了一個上下文，這個上下文返回另一個函數(shù)，
// 此函數(shù)中可以應(yīng)用此上下文中的變量，這就是閉包（Closure）。
// 這是JavaScript框架開發(fā)中常用的技巧。
F.prototype[name] = (function(name, fn) {
return function() {
this.base = baseClass.prototype[name];
return fn.apply(this, arguments);
};
})(name, prop[name]);
} else {
F.prototype[name] = prop[name];
}
}
}
return F;
};
var Person = jClass({
init: function(name) {
this.name = name;
},
getName: function() {
return this.name;
}
});
var Employee = jClass(Person, {
init: function(name, employeeID) {
this.base(name);
this.employeeID = employeeID;
},
getEmployeeID: function() {
return this.employeeID;
},
getName: function() {
return "Employee name: " + this.base();
}
});
var zhang = new Employee("ZhangSan", "1234");
console.log(zhang.getName()); // "Employee name: ZhangSan"
至此，我們已經(jīng)創(chuàng)建了一個完善的函數(shù)jClass， 幫助我們在JavaScript中以比較優(yōu)雅的方式實現(xiàn)類和繼承。
在以后的章節(jié)中，我們會陸續(xù)分析網(wǎng)上一些比較流行的JavaScript類和繼承的實現(xiàn)。 不過萬變不離其宗，那些實現(xiàn)也無非把我們這章中提到的概念顛來簸去的“炒作”， 為的就是一種更優(yōu)雅的調(diào)用方式。
JavaScript技術(shù)：JavaScript 繼承詳解（三），轉(zhuǎn)載需保留來源！
鄭重聲明：本文版權(quán)歸原作者所有，轉(zhuǎn)載文章僅為傳播更多信息之目的，如作者信息標記有誤，請第一時間聯(lián)系我們修改或刪除，多謝。
