沿袭体系 -class.js

继承体系 --class.js

//继承 //实现singlaton //可以调用基类函数 //JavaScript通过构造函数和原型的方式模拟实现了类的功能。     var Class = (function(){      //IE不会遍历几个特殊属性："constructor", "toString", "valueOf"      var IS_DONTENUM_BUGGY = void function(){         for (var p in { toString: 1}) return false;         return true;     }();      function create(options){         var options = options || {}, uniqueInstance = null;         //判定是否需要实现单例          var singleton = !!options.singleton;         delete options.singleton;         //父类         var superclass = options.inherit || {};         delete options.inherit;                  function klass(){             if (!singleton)  this.init.apply(this, arguments);         }         //添加类方法         $U.extend(klass, Class.Methods);         //是否继承         if ($U.isFunction(superclass)) {             var bridge = function(){};             bridge.prototype = superclass.prototype;             klass.prototype = new bridge;             klass.superclass = superclass;         }         //添加原型方法         klass.addMethods(options);                  if (!klass.prototype.init)              klass.prototype.init = function(){             };         //修正constructor             klass.prototype.constructor = klass;         //__proto__是什么？我们在这里简单地说下。每个对象都会在其内部初始化一个属性，就是__proto__，当我们访问一个对象的属性时，如果         //这个对象内部不存在这个属性，那么他就会去__proto__里找这个属性，这个__proto__又会有自己的__proto__，于是就这样         //一直找下去，也就是我们平时所说的原型链的概念。         //按照标准，__proto__是不对外公开的，也就是说是个私有属性，但是Firefox的引擎将他暴露了出来成为了一个共有的属性，         //我们可以对外访问和设置。                  //修复IE与Opera中的第二条原型链         if (!klass.prototype.__proto__) klass.prototype.__proto__ = klass.prototype;                           //处理函数：如果singleton模式，则private constructor         return singleton ? {             getInstance: function(){                 if (!uniqueInstance) {// Instantiate only if the instance doesn't exist.                     uniqueInstance = new klass;                     uniqueInstance.init.apply(uniqueInstance, arguments);                 }                 return uniqueInstance;             }         } : klass;     }     function addMethods(source){         var ancestor = this.superclass && this.superclass.prototype, properties = $U.keys(source);         //处理IE不能遍历的特殊属性。         if (IS_DONTENUM_BUGGY) {             if (source.toString != Object.prototype.toString)                  properties.push("toString");             if (source.valueOf != Object.prototype.valueOf)                  properties.push("valueOf");         }         for (var i = 0, length = properties.length; i < length; i++) {             var property = properties[i], value = source[property];             //在C#中,如果子类有意隐藏基类成员，使用关键字"new"             //使用base关键字显示调用基类构造函数             //这这里约定如果子类方法第一个参数是“$super”，则调用父类的方法.             if (ancestor && $U.isFunction(value) && (value.argumentNames()[0] === "$super")) {                 var method = value;                 //var f = (function(m){ return function(){ return ancestor[m].apply(this, arguments)}})(property)                 //f.wrap(method)                                  //F.prototype[name] = (function(name, fn) {                 //    return function() {                 //        var that = this;                 //        $super = function() {                 //            return baseClass.prototype[name].apply(that, arguments);                 //        };                 //        return fn.apply(this, Array.prototype.concat.apply($super, arguments));                 //    };                 //})(name, prop[name]);                                                   //总之，实现把基类函数作为子函数的第一个参数，以此调用父函数。                 value = ancestor[property].wrap(method);                 value.valueOf = method.valueOf.bind(method);                 // 因为我们改变了函数体，所以重新定义函数的toString方法                 // 这样用户调用函数的toString方法时，返回的是原始的函数定义体                 value.toString = method.toString.bind(method);             }             this.prototype[property] = value;         }         return this;     }     return {         create: create,         Methods: {             addMethods: addMethods         }     }; })()   //继承 //实现singlaton  var F = function(){ }; F.prototype.getInstance = function(){      var instance = null;          return function(){         if (!instance)              instance = new this;         return instance;     };      }();