|
|
/*
base2.js - copyright 2007, Dean Edwards
http://www.opensource.org/licenses/mit-license
*/
// You know, writing a Javascript library is awfully time consuming.
//////////////////// BEGIN: CLOSURE ////////////////////
// =========================================================================
// base2/Base.js
// =========================================================================
// version 1.1
var Base = function(){
// call this method from any other method to invoke that method's ancestor
};
Base.prototype = {
extend: function(source){
//參數大于一個時
if (arguments.length > 1) { // extending with a name/value pair
//獲得proto的祖先
var ancestor = this[source];
var value = arguments[1];
//如果value（第二個參數）是function，并且祖先對象存在，在重載函數中調用base時
if (typeof value == "function" && ancestor && //bbase/b/.test(value)) {
// get the underlying method
var method = value;
// override
value = function(){
var previous = this.base;
this.base = ancestor;
//上溯到父類對象
var returnValue = method.apply(this, arguments);
this.base = previous;
return returnValue;
};
value.method = method;
value.ancestor = ancestor;
}
this[source] = value;
}
else
if (source) { // extending with an object literal 用一個對象列表來擴展
var extend = Base.prototype.extend;
/**
* 1.擴展原型方法和屬性 2.
*/
//如果是擴展屬于原型的方法或屬性,先遍歷其重載Object的3個方法
if (Base._prototyping) {
var key, i = 0, members = ["constructor", "toString", "valueOf"];
while (key = members[i++]) {
//如果是重載了這些方法
if (source[key] != Object.prototype[key]) {
/**
* 逐個擴展,用call的原因是要將extend的上下文改為要擴展的源this,
* 既是新建對象的父類對象
*/
extend.call(this, key, source[key]);
}
}
}
else
if (typeof this != "function") {
// if the object has a customised extend() method then use it
extend = this.extend || extend;
}
// copy each of the source object's properties to this object
for (key in source)
if (!Object.prototype[key]) {
extend.call(this, key, source[key]);
}
}
return this;
},
base: Base
};
Base.extend = function(_instance, _static){ // subclass
/**
* Base類原型的擴展別名,將這個當成一個方法調用
*/
var extend = Base.prototype.extend;
/**
* build the prototype,創建原型
* 設置原型標志
*/
Base._prototyping = true;
/**
* 創建一個Base的實例,初始化繼承部分
* 繼承方式大致還是以下方式
* function A(){}
* function B(){
* this.b=[];
* }
* A.prototype=new B();//A繼承B的所有屬性和方法
* 這種繼承方式會有一個問題,B中聲明的對象(如b)以prototype的形式
* 被A繼承之后,prototype只是生成一個指向B中對象的引用,即
* A所有實例會共同享有B中對象(b)
* var a1=new A();
* var a2=new A();
* a1.b.push("a11");
* a2.b.push("a21");
* 此時,a1.b=a2.b=["a11","a21"],
*
* Dean Edwards在實現繼承的時候,以父類為基礎,創建實例,
* 利用extend擴展該實例,最后用A.prototype=new B();實現繼承
* 但是屬性是對象的時候沒有做處理,
* 還是沒有避開上述的繼承缺陷
*/
var proto=new this;
/**
* 在這里,不可以用 proto.extend(_instance)代替
*/
extend.call(proto, _instance);
/**
* 類實例屬性和方法的原型部分構造完畢,刪除標志位
*/
delete Base._prototyping;
/**
* 這里作者運用了適配器的模式,用自定義的構造器生成一個新的類對象
* wrapper/adapter:通過一定的方法，一個對象封裝或授權另一個
* 對象來改變它的接口或者行為
*/
// create the wrapper for the constructor function
/**
* 獲得構造器的引用
*/
var constructor = proto.constructor;
/**
* 建立klass的Function對象,調用自定義的構造器, klass就是衍生的子類
* 兩種情況下,調用此方法:
* 1.創建類實例的時候,這時候不是原型構造階段,執行由extend方法
* 繼承的時候設定的構造方法
* 2.當用extend方法衍生子類的時候---new this
* 因為下文中klass的屬性已經全部獲得,
* 所以當new完之后,獲得所有父類的方法和屬性都包含在了
* proto里面了,這時候,在proto的基礎上運用prototype的extend方法
* 將此子類的屬性和方法添加到proto里面
*/
var klass = proto.constructor = function(){
/**
* var proto=new this; 調用父類的構造函數,創建一個父類的實例
* new this用完后,函數重定向到子類對象構造方法
*/
if (!Base._prototyping) {
/**
* 當在構造函數中(constructor)調用base方法時,
* base方法會調用父類對象的構造函數,這時候會嵌套
* 調用這個代碼段,方法得以執行的條件就是this._constructing==true
*/
if (this._constructing || this.constructor == klass) { // instantiation
this._constructing = true;
constructor.apply(this, arguments);
delete this._constructing;
}
/**
*
* 不再向下執行
*/
else { // casting
var object = arguments[0];
if (object != null) {
(object.extend || extend).call(object, proto);
}
return object;
}
}
};
// build the class interface
/**
*
*/
for (var i in Base){
klass[i] = this[i];
}
/**
* 創建繼承鏈
*/
klass.ancestor = this;
klass.base = Base.base;
klass.prototype = proto;
klass.toString = this.toString;
/**
* 擴展類方法,屬性,類似Java的static
*/
extend.call(klass, _static);
// class initialisation 如果存在init函數 調用
if (typeof klass.init == "function")
klass.init();
return klass;
};
// initialise
Base = Base.extend({
constructor: function(){
this.extend(arguments[0]);
}
}, {
ancestor: Object,
base: Base,
implement: function(_interface){
if (typeof _interface == "function") {
// if it's a function, call it
_interface(this.prototype);
}
else {
// add the interface using the extend() method
this.prototype.extend(_interface);
}
return this;
}
});
JavaScript技術：js繼承 Base類的源碼解析，轉載需保留來源！
鄭重聲明：本文版權歸原作者所有，轉載文章僅為傳播更多信息之目的，如作者信息標記有誤，請第一時間聯系我們修改或刪除，多謝。
