jsはBase class_jsのソースコード解析を継承してオブジェクト指向化

// タイムスタンプ: 火曜日、01 5 月 2007 19:13:00
/*
base2.js - 著作権 2007、Dean Edwards
http://www.opensource.org/licenses/mit-license
*/
// ご存知のとおり、JavaScript ライブラリの作成には非常に時間がかかります。
//////////////////// BEGIN: CLOSURE // / //////////////////
// ========================== == =============================================
//base2/Base.js
// ===================================== ==== =================================
// バージョン 1.1
var Base = function(){
// 他のメソッドからこのメソッドを呼び出し、そのメソッドの祖先
};
Base.prototype = {
extend: function(source){
//Whenパラメータは 1 より大きい
if (arguments.length > 1) { // 名前と値のペアで拡張します
// proto の祖先を取得します
var ancestor = this[source]; >var value = argument[1] ;
//value (2 番目のパラメーター) が関数であり、先祖オブジェクトが存在する場合、base がオーバーロードされた関数で呼び出されるとき
if (typeof value == "function" && ancestor && /bbaseb/.test (value) {
// 基になるメソッドを取得します
var method = value;
//
value = function(){
varPrevious = this. base;
this.base = ancestor;
//親クラス オブジェクトに戻ります
var returnValue = method.apply(this, argument);
this.base =Previous;戻り値;
} ;
値.メソッド = メソッド;
この[ソース] = 値; >if (source) { // オブジェクト リテラルで拡張する オブジェクトのリストを使用して拡張します
var extend = Base.prototype.extend;
/**
* 1. プロトタイプのメソッドとプロパティを拡張します。 2.
*/
//プロトタイプに属するメソッドまたはプロパティを拡張しています。まず、オーバーロードされたオブジェクトの 3 つのメソッドを調べます。
if (Base._prototyping) {
var key, i = 0, members = ["constructor", "toString", "valueOf"];
while (key = members[i ]) {
//これらのメソッドがオーバーロードされている場合
if (source[key] != Object.prototype[key]) {
/**
* 1 つずつ展開します。call を使用する理由は、extend のコンテキストを拡張対象のソースに変更するためです。
* は、新しいオブジェクト
の親クラスのオブジェクトです。* /
extend.call(this, key, source[key]);
}
}
}
else
if (typeof this != "function") {
// オブジェクトにカスタマイズされた extend() メソッドがある場合は、それを使用します
extend = this.extend || extend;
}
// ソース オブジェクトのそれぞれをコピーしますこのオブジェクトへのプロパティ
for (ソース内のキー)
if (!Object.prototype[key]) {
extend.call(this, key, source[key]); >}
これを返します ;
},
base: Base
}
Base.extend = function(_instance, _static){ // サブクラス
/**
* Base クラスのプロトタイプの拡張エイリアス。これをメソッドとして呼び出します
*/
var extend = Base.prototype.extend;
/**
* プロトタイプをビルドする、プロトタイプを作成する
* プロトタイプ フラグを設定する
*/
Base._prototyping = true;
/**
* Base と継承部分の初期化
* 継承方法は大まかに以下の通りです。
* function A(){}
* function B(){
* this.b=[]; }
* A.prototype=new B();//A inherits all properties and methods of B
* There is a problem with this inheritance method. The objects declared in B (such as b) are in the form of prototype
* After being inherited by A, prototype just generates a reference to the object in B, that is,
* all instances of A will share the object in B (b)
* var a1=new A();
* var a2=new A();
* a1.b.push("a11");
* a2.b.push("a21");
* At this time, a1.b =a2.b=["a11","a21"],
* Here, proto.extend(_instance) cannot be used instead of
* When Dean Edwards implements inheritance, he creates an instance based on the parent class,
* uses extend to extend the instance, and finally uses A. prototype=new B(); implements inheritance
* but does not handle the properties when they are objects.
* still does not avoid the above inheritance defects
*/
var proto=new this;
/**
* The prototype part of the class instance attributes and methods is constructed, and the flag bit is deleted
*/
extend.call(proto, _instance);
/**
* Here the author uses the adapter pattern, using a custom constructor to generate a new class object
* wrapper/adapter: Through a certain method, one object encapsulates or authorizes another
* object to Change its interface or behavior
*/
delete Base._prototyping;
/**
* Get a reference to the constructor
*/
// create the wrapper for the constructor function
/**
* Create the Function object of klass and call the custom constructor. klass is the derived subclass
* In two cases, call this method:
* 1. When creating a class instance, at this time It is not the prototype construction phase, and the construction method set by the extend method
* when inheriting is executed
* 2. When using the extend method to derive a subclass---new this
* because of klass below All attributes have been obtained,
* so after new is completed, all the methods and attributes of the parent class are included in
* proto. At this time, use the extend method of prototype on the basis of proto
* Add the attributes and methods of this subclass to proto
*/
var constructor = proto.constructor;
/**
* var proto=new this; Call the constructor of the parent class and create an instance of the parent class
* After new this is used up, the function redirects to the subclass object construction method
*/
var klass = proto.constructor = function(){
/**
* When the base method is called in the constructor, the
* base method will call the constructor of the parent class object. At this time, the
* call this code segment will be nested, and the method will be executed. The condition is this._constructing==true
*/
if (!Base._prototyping) {
/**
*
* will no longer execute downward
*/
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
/**
* Create inheritance chain
*/
for (var i in Base){
klass[i] = this[i];
}
/**
* Extend class methods, properties, similar to java's static
*/
klass.ancestor = this;
klass.base = Base.base;
klass.prototype = proto;
klass.toString = this.toString;
/***/
extend.call(klass, _static );
// class initialisation If there is an init function call
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;
}
});