dom Framework oop模块

此模块提供强大的面向对象编程能力，非常感谢mootools等先行者做出的有益探索，虽然现在我放出来的版本比最初的削减了许多功能，但依然非常强大。

/*dom Framework version 1.0
Copyright 2010
Dual licensed under the MIT or GPL Version 2 licenses.
author: <ruby> <rb>司徒正美<rp>(zhongqincheng)</rp></rb><rt>しとぅなさみ</rt></ruby>
http://www.cnblogs.com/rubylouvre/
*/
   //=========================================
    // OOP模块 提供强大的面向对象编程， ruby风格的继承机制
    //==========================================
    ;;;(function(dom,window,undefined){
        dom.provide("oop");
 
        var classMethods = (function() {
            var include = ["constructor"],
            extend  = 'prototype $supers $super extend include'.toArray();
            function cleanModule(module, array) {
                array = array == 'extend' ? extend : include
                for(var key in module){
                    if(module.hasOwnProperty(key) && array.contains(key)){
                        delete module[key]
                    }
                }
                return module;
            }
            return {
                //桥梁模式，将实现化与抽象化脱耦，便得两者可以独立地变化
                //http://javascript.crockford.com/prototypal.html
                inherit: function(parent) {
                    if (parent && parent.prototype) {
                        var bridge = function() {};
                        bridge.prototype = parent.prototype;
                        this.prototype = new bridge;
                        this.$super = parent;
                    }
                    this.$supers = [];//这里的this为类
                    while (parent) {
                        if(!dom.isPureObject(parent)){//父类不能为默认添加的Object
                            this.$supers.push(parent);
                            parent = parent.$super;
                        }
                    }
                    return this.prototype.constructor = this;
                },
                alias : function(oldName, newName){
                    var proto = this.prototype;
                    if (dom.isString(oldName)){
                        var method = proto[oldName]
                        method && (proto[newName] = method);
                    }else if(is(oldName,"Object")){
                        dom.each(oldName,function(neo,old){
                            this.alias(old,neo)
                        },this)
                    }
                    return this;
                },
                //为新类添加一些类成员
                extend: function() {
                    dom.toArray(arguments).each(function(module){
                        dom.mixin(this, cleanModule(module, 'extend'));
                    },this);
                    return this;
                },
                //为新类添加原型成员，如果它们是函数，则判断其与父类有没有同名方法，
                //有则改写当前类的成员，在它上面添加一个$super属性
                include: function() {
                    var $supers = this.$supers.pluck('prototype');
                    dom.slice(arguments).each(function(module){
                        cleanModule(module, 'include');//去除模块包中那些危险属性
                        dom.keys(module).each(function(key){
                            var value = module[key],isFn = dom.is(value,"Function");
                            if(key.startsWith("protected ")){
                                key = key.toArray()[1];
                                if(isFn){
                                    value._protected = true;
                                }
                            }
                            var parent = $supers.first(function(proto) {
                                return dom.is(proto[key],"Function");
                            });
                            this.prototype[key] = isFn ?
                            (function( method,  key, parent) {
                                return function() {
                                    parent && (this.$super = parent[key]);      
                                    if (method._protected && this._method == null){
                                        throw new Error('The method "' + key + '" is protected!');
                                    }
                                    this._method = arguments.callee;
                                    var result = method.apply(this, arguments);
                                    delete this._method;
                                    return result;
                                };
                            })(value,  key, parent) :value;
                            if(isFn){
                                this.prototype[key].toString = function(){
                                    return String(value);
                                }
                            }
                        },this);
                    },this);
                    return this;
                }
            }
        })();
        //第一类工厂
        //{inherit :superclass,include:instance_member,extend:class_member,singleton：boolean}
        dom.oop = function(obj){
            obj = obj || {};
            //新类的原始构造器
            var init = init || obj.init || dom.noop;
            delete obj.init;
            //父类
            var superclass = obj.inherit || Object;
            //判定是否需要实现单例
            var singleton  = !!obj.singleton ;
            delete obj.singleton;
            //------------------创建新类--------------------------------------------
            var klass = function() {
                if(singleton && klass.instance){//实现单例模式
                    return klass.instance
                }
                superclass.apply(this, arguments);
                init.apply(this, arguments);
                if(singleton)
                    klass.instance = this;
                return this;
            };
            //添加泛化成员与原型成员
            dom.mixin(klass, classMethods).inherit(superclass);
            ["extend", "include"].each(function(name) {
                if (obj[name]) {
                    var modules = dom.toArray(obj[name]);
                    klass[name].apply(klass, modules);
                    delete obj[name];
                }
            });
            var proto = klass.prototype;
            klass.include(obj);
            if(!proto.__proto__){//修复IE与Opera中的第二条原型链
                proto.__proto__ = proto
            }
            proto.$super = superclass;
            klass.toString = function(){//重写构造子的toString
                return init.toString();
            }
            return klass
        }
    })(window[escape(document.URL.split("#")[0])],this);

一些示例：

继承。

var Animal = dom.oop({
  init: function(name) {
    this.name = name;
  },
  eat: function() {
    dom.console.log('yummie');
  }
});
 
 
var Human = dom.oop({
  inherit: Animal,//注意这里，使用inherit
  speak: function() {
    dom.console.log(this.name + ' said bla bla bla');
  }
});
 
var peter = new Human('peter');
peter.eat();//yummie
peter.speak();//peter said bla bla bla
 
var Pat = dom.oop({
  inherit: Human,//注意这里，使用inherit
  init: function(name,age) {//注意这里name
    this.age = age//隐式调用父类构造子
  }
});
 
var pat = new Pat('pat',18);
dom.console.log(pat.name)//pat
dom.console.log(pat.age)//18
pat.speak();//pat said bla bla bla

单例类。

var God = dom.oop({
  init:function(name){
    this.name = name;
    this.alertName = function(){
      dom.console.log(this.name)
    }
  },
  singleton:true//注意这里，使用singleton属性
});
var god = new God("耶和华");
god.alertName();      //alerts 耶和华
var lucifer = new God("撒旦");
lucifer.alertName();   //alerts 耶和华
dom.console.log(god === lucifer )//alerts true

内部方法，只能用于类的内部与其子类。注意，是方法不是属性。

var Person = dom.oop({
  init: function(name){
    this.name = name;
  },
  "protected secret": function(){//定义一个内部方法，要用"protected "作为前缀
    return 'I sometimes like girly drinks';
  }, 
 
  describe: function(){
    return "Hi, I'm #{name}. #{secret}. I kid, I kid.".instead({
      name: this.name,
      secret: this.secret()
    });
  }
});
 
var scott = new Person('司徒正美');
try{
  scott.secret()
}catch(e){
  dom.console.error(e);//Error: The method "secret" is protected!
}
dom.console.log(scott.describe());//Hi, I'm Scott. I sometimes like girly drinks. I kid, I kid.