关于js继承---Base类的源码解析

 
   Base据说是最好的js继承的封装类,最近读了一下base2.js的继承部分,现在将源码的解析贴下,有错误的地方希望大家指出,我会更新的.

1. // timestamp: Tue, 01 May 2007 19:13:00
2. /*
3.  base2.js - copyright 2007, Dean Edwards
4.  http://www.opensource.org/licenses/mit-license
5.  */
6. // You know, writing a javascript library is awfully time consuming.
7. ////////////////////  BEGIN: CLOSURE  ////////////////////
8. // =========================================================================
9. // base2/Base.js
10. // =========================================================================
11. // version 1.1
13. var Base = function(){
14.     // call this method from any other method to invoke that method's ancestor
15. };
17. Base.prototype = {
18.     extend: function(source){
19.         //参数大于一个时
20.         if (arguments.length > 1) { // extending with a name/value pair
21.             //获得proto的祖先
22.             var ancestor = this[source];
23.             var value = arguments[1];
24.             //如果value（第二个参数）是function，并且祖先对象存在，在重载函数中调用base时
25.             if (typeof value == "function" && ancestor && //bbase/b/.test(value)) {
26.                 // get the underlying method
27.                 var method = value;
28.                 // override
29.                 value = function(){
30.                     var previous = this.base;
31.                     this.base = ancestor;
32.                     //上溯到父类对象
33.                     var returnValue = method.apply(this, arguments);
34.                     this.base = previous;
35.                     return returnValue;
36.                 };
37.                 value.method = method;
38.                 value.ancestor = ancestor;
39.             }
40.             this[source] = value;
41.         }
42.         else 
43.             if (source) { // extending with an object literal 用一个对象列表来扩展
44.                 var extend = Base.prototype.extend;
45.                 /**
46.                  *   1.扩展原型方法和属性 2.
47.                  */
48.                 //如果是扩展属于原型的方法或属性,先遍历其重载Object的3个方法
49.                 if (Base._prototyping) {
50.                     var key, i = 0, members = ["constructor", "toString", "valueOf"];
51.                     while (key = members[i++]) {
52.                         //如果是重载了这些方法
53.                         if (source[key] != Object.prototype[key]) {
54.                             /**
55.                              * 逐个扩展,用call的原因是要将extend的上下文改为要扩展的源this,
56.                              * 既是新建对象的父类对象
57.                              */
58.                             extend.call(this, key, source[key]);
59.                         }
60.                     }
61.                 }
62.                 else 
63.                     if (typeof this != "function") {
64.                         // if the object has a customised extend() method then use it
65.                         extend = this.extend || extend;
66.                     }
67.                 // copy each of the source object's properties to this object
68.                 for (key in source)
69.                     if (!Object.prototype[key]) {
70.                         extend.call(this, key, source[key]);
71.                     }
72.             }
73.         return this;
74.     },
75.     
76.     base: Base
77. };
79. Base.extend = function(_instance, _static){ // subclass
81.     /**
82.      * Base类原型的扩展别名,将这个当成一个方法调用
83.      */
84.     var extend = Base.prototype.extend;
85.     /**
86.      * build the prototype,创建原型
87.      * 设置原型标志
88.      */
89.     Base._prototyping = true;
90.     /**
91.      * 创建一个Base的实例,初始化继承部分
92.      * 继承方式大致还是以下方式
93.      * function A(){}
94.      * function B(){
95.      *     this.b=[];
96.      * }
97.      * A.prototype=new B();//A继承B的所有属性和方法
98.      * 这种继承方式会有一个问题,B中声明的对象(如b)以prototype的形式
99.      * 被A继承之后,prototype只是生成一个指向B中对象的引用,即
100.      * A所有实例会共同享有B中对象(b)
101.      * var a1=new A();
102.      * var a2=new A();
103.      * a1.b.push("a11");
104.      * a2.b.push("a21");
105.      * 此时,a1.b=a2.b=["a11","a21"],
106.      *
107.      * Dean Edwards在实现继承的时候,以父类为基础,创建实例,
108.      * 利用extend扩展该实例,最后用A.prototype=new B();实现继承
109.      * 但是属性是对象的时候没有做处理,
110.      * 还是没有避开上述的继承缺陷
111.      */
112.     var proto=new this;
113.     /**
114.      * 在这里,不可以用 proto.extend(_instance)代替
115.      */
116.     extend.call(proto, _instance);
117.     /**
118.      * 类实例属性和方法的原型部分构造完毕,删除标志位
119.      */
120.     delete Base._prototyping;
121.     
123.     /**
124.      * 这里作者运用了适配器的模式,用自定义的构造器生成一个新的类对象
125.      * wrapper/adapter:通过一定的方法，一个对象封装或授权另一个
126.      * 对象来改变它的接口或者行为
127.      */
128.     // create the wrapper for the constructor function
130.     /**
131.      *  获得构造器的引用
132.      */
133.     var constructor = proto.constructor;
135.     /**
136.      * 建立klass的Function对象,调用自定义的构造器, klass就是衍生的子类
137.      * 两种情况下,调用此方法:
138.      * 1.创建类实例的时候,这时候不是原型构造阶段,执行由extend方法
139.      * 继承的时候设定的构造方法
140.      * 2.当用extend方法衍生子类的时候---new this
141.      * 因为下文中klass的属性已经全部获得,
142.      * 所以当new完之后,获得所有父类的方法和属性都包含在了
143.      * proto里面了,这时候,在proto的基础上运用prototype的extend方法
144.      * 将此子类的属性和方法添加到proto里面
145.      */
146.     var klass = proto.constructor = function(){
147.         /**
148.          * var proto=new this; 调用父类的构造函数,创建一个父类的实例
149.          * new this用完后,函数重定向到子类对象构造方法
150.          */
151.         if (!Base._prototyping) {
152.             /**
153.              * 当在构造函数中(constructor)调用base方法时,
154.              * base方法会调用父类对象的构造函数,这时候会嵌套
155.              * 调用这个代码段,方法得以执行的条件就是this._constructing==true
156.              */
157.             if (this._constructing || this.constructor == klass) { // instantiation
158.                 this._constructing = true;
159.                 constructor.apply(this, arguments);
160.                 delete this._constructing;
161.             }
162.             /**
163.              * 
164.              * 不再向下执行
165.              */
166.             else { // casting
167.                 var object = arguments[0];
168.                 if (object != null) {
169.                     (object.extend || extend).call(object, proto);
170.                 }
171.                 return object;
172.             }
173.         }
174.     };
175.     
176.     // build the class interface
177.     /**
178.      * 
179.      */
180.     for (var i in Base){
181.         klass[i] = this[i];
182.     }
183.     /**
184.      * 创建继承链
185.       */
186.     klass.ancestor = this;
187.     klass.base = Base.base;
188.     klass.prototype = proto;
189.     klass.toString = this.toString;
190.     /**
191.      * 扩展类方法,属性,类似java的static
192.      */
193.     extend.call(klass, _static);
194.     
195.     // class initialisation   如果存在init函数 调用
196.     if (typeof klass.init == "function") 
197.         klass.init();
198.     return klass;
199. };
201. // initialise
202. Base = Base.extend({
203.     constructor: function(){
204.         this.extend(arguments[0]);
205.     }
206. }, {
207.     ancestor: Object,
208.     base: Base,
209.     
210.     implement: function(_interface){
211.         if (typeof _interface == "function") {
212.             // if it's a function, call it
213.             _interface(this.prototype);
214.         }
215.         else {
216.             // add the interface using the extend() method
217.             this.prototype.extend(_interface);
218.         }
219.         return this;
220.     }
221. });