但是作者Nicholas C. Zakas在【動態原型】方式創建對象的時候沒有深究可能會存在的問題和解決方案。而僅僅在繼承的時候對【動態原型】的瓶頸作了說明。即在作子類繼承的時候，不能通過動態原型的方式來實現。
原文大致如下：
繼承機制不能采用動態化的原因是：prototype對象的唯一性。實例代碼：
function A (i) {
this.a = i;
if (typeof A._init == 'undefined') {
A.prototype.func = function () {
return 0;
}
A._init = 1;
}
}
function subA (j) {
A.call(this, 1);
this.j = j;
if (typeof subA._init == 'undefined') {
subA.prototype = new A();
subA.prototype.func_sub = function () {
return ++j;
}
subA._init = 1;
}
}
var sub_a = new subA(1);
alert(sub_a.func_sub()); //error: sub_a.func_sub is not a function
Nicholas解釋說在代碼運行前，對象已被實例，并與prototype聯系，在當前對prototype對象替換不會對它產生任何影響，即當前的替換是訪問不到的，只有未來對象的實例才會反映出這種改變。于是第一個實例對象就會不正確。但第二個及以后的子類實例都沒問題。
解決方法就是在構造函數外賦予新的prototype對象：
function A (i) {
this.a = i;
if (typeof A._init == 'undefined') {
A.prototype.func = function () {
return 0;
}
A._init = 1;
}
}
function subA (j) {
A.call(this, 1);
this.j = j;
if (typeof subA._init == 'undefined') {
subA.prototype.func_sub = function () {
return ++j;
}
subA._init = 1;
}
}
subA.prototype = new A();
var sub_a = new subA(1);
alert(sub_a.func_sub()); //2
可惜這違反了我們為什么使用動態原型的初衷。
使用動態原型的初衷本來就是要讓構造函數能“統一江山”，在視覺上讓人覺得原型方法是類構造的一部分。
以上是《JavaScript高級程序設計》中對動態原型繼承小節的大概內容。
<! -- ========== 分割線 ============ -->
可是Nicholas在先前的章節講對象構造的【動態原型】方式中，似乎忘了提這個同樣的問題。我們看看上文中最后一個例子：
var Obj = function (name) {
this.name = name;
this.flag = new Array('A', 'B');
if (typeof Obj._init == 'undefined') {
Obj.prototype = {
showName : function () {
alert(this.name);
}
};
Obj._init = true;
}
}
var obj1 = new Obj('aa');
var obj2 = new Obj('bb');
obj1.showName(); //error: is not a function
obj2.showName(); // bb;
是的，這個問題其實和子類繼承中出現的問題如出一轍，prototype在當前的替換是不會對該對象有任何影響的，只有在未來的實例中可見。如果按照Nicholas處理動態原型繼承的方式中說的一樣，那就意味著只能在構造函數外邊重新賦予prototype對象。那么這不就成了【構造函數/原型混合】方式了嗎？所謂的【動態原型】方式也就不存在了...
其實我們可以想想，為什么在【構造函數/原型混合】這種已經基本沒有副作用的構建對象方式后面還要在寫一節【動態原型】方式。作者的意圖無非就是想讓構造函數在視覺上更為統一么。其實僅僅要視覺上的統一可以不用動態原型的。
var Obj = function () {
function __initialize (name) {
this.name = name;
this.flag = new Array('A', 'B');
}
__initialize.prototype = {
showName : function () {
alert(this.name);
},
showFlag : function () {
alert(this.flag);
}
}
return __initialize;
}();
var obj1 = new Obj('aa');
var obj2 = new Obj('bb');
obj1.showName(); // aa
obj2.showName(); // bb
其實上面的方式就可以算是視覺的統一了，Obj的構造函數內通過__initialize來初始化屬性，通過__initialize.prototype原型初始化方法。只不過稍微有點“小作弊”的感覺，__initialize代理了Obj的初始化...
下面是來自tangoboy的“構造類”的封裝，其實思路和上面基本一致，唯一不同的是他把屬性也用原型方式創建了，同時把初始化屬性和方法都扔到了構造函數參數對象里。方便自定義：
/* == form tangoboy == */
window['$Class'] = {
//創建一個類 混合構造函數/原型方式
create: function(config) {
var obj = function(){},config = config||{};
//過濾構造方法和原型方法
obj = obj.prototype.constructor = config["__"]||obj;
delete config["__"];
obj.prototype = config;
return obj;
}
}
/* -- eg -- */
var man = $Class.create({
__ : function (name) {
this.name = name;
},
sex : 'male',
showName : function () {
alert(this.name);
}
});
var me = new man('ru');
me.showName(); //ru
其實如果硬要追求視覺的統一也可以不用動態原型的方式。說到底看看上面的思路，已經回溯到了我們最常用的“類構造”方式：
var Class = {
create : function () {
return function () {
this.initialize.apply(this, arguments);
}
}
}
相信上面這段代碼大家或許都不會陌生，如果細究下去，會發現其實和上面的代碼都一致，用initialize函數作了初始化的代理，從而完成了視覺的統一。
