我的js类（续）

之前的写过一篇关于js类的《文章》，主要是贴了一下代码和用法，功能上也有些欠缺。新版的Class增加了私有属性、接口两个功能。需要注意的是继承、调用父类方法、使用私有方法都是很耗费资源的，如果非得使用尽量减少继承的层数。（本人的小demo）

主要贴一下私有属性和接口用法：

1、私有属性

 

//设置私有属性this.$(key,value);获取私有属性:this.$(key);
Class('Dog',{
	initialize:function(){
		//为Dog设置私有属性name
		this.$('name','dog');
	},
	speak:function(){		
		//打印Dog私有属性name
		console.log('Dog name is ',this.$('name'));
	}
	
})
Class('BlackDog',{
	superclass:Dog,
	initialize:function(){
		this.callSuper();
		//为BlackDog也设置私有属性name，检查子类和父类里的私有属性是否冲突
		this.$('name','blackdog');
	},
	speak:function(){
		this.callSuper();
		//打印BlackDog私有属性name
		console.log('BlackDog name is ',this.$('name'));
	}
})
//正确结果应该Dog里的name和BlackDog里的name没有关系，BlackDog不能覆盖Dog里的私有属性
var blackdog=new BlackDog();
blackdog.speak();

结果为：

 

Dog name is dog
BlackDog name is blackdog

2、接口

 

Interface('Animal',['eat']);//接口名称、方法
Class('Pig',{
	interfaces:[Animal]
})
Interface('Animal',['eat']);//接口名称、方法
Class('Cat',{
	interfaces:[Animal],
	eat:function(){
		
	}
})

结果为：

报错：Error: the method 'eat' need to implement in class 'Pig'!

 

下边是新版的源码：

 

(function () {
    var emptyArgs = [],
        emptyFn = function () {
        },
    //暂时未用
        noInvokeResult = {
            execute: emptyFn
        },
    //暂时未用
        invokeSuperResult = {
            execute: function () {
                var result = this.method.apply(this.obj, arguments || emptyArgs);
                this.obj = null;
                this.method = null;
                return result;
            }
        },
    //暂时未用
        enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
    //命名空间
    function namespace() { // namespace
        var a = arguments,
            al = a.length,
            o = null,
            i,
            j,
            d,
            dl,
            rt;
        for (i = 0; i < al; ++i) {
            d = a[i].split(".");
            rt = d[0];
            eval('if (typeof ' + rt + ' == "undefined"){' + rt + ' = {};} o = ' + rt + ';');
            dl = d.length;
            for (j = 1; j < dl; ++j) {
                o[d[j]] = o[d[j]] || {};
                o = o[d[j]];
            }
        }
        return o;
    }

    //继承父类方法
    function inherit(C, superClass) {
        if (typeof(superClass) != 'function') {
            return C;
        }
        function F() {
        }

        F.prototype = superClass.prototype;
        C.prototype = new F();
        C.prototype.constructor = C;
        C.superclass = superClass;
        return C;
    }

    //绑定方法到对象
    function bindMethods(object, methods) {
        for (var name in methods) {
            if (methods.hasOwnProperty(name)) {
                object[name] = methods[name];
            }
        }
    }

    //添加方法到原型
    function addMethods(C, methods) {
        var p = C.prototype,
            _methods_ = C._methods_;
        for (var name in methods) {
            var m = methods[name];
            p[name] = m;
            if (name != 'callSuper' && name != 'invokeSuper') {
                m['_name_'] = name;
                m['_owner_'] = C;
                if (_methods_.indexOf(name) == -1) {
                    _methods_.push(name);
                }
            }
        }
        return C;
    }

    //TODO 1、需增加获取静态属性、方法的方法2、增加获取祖先的方法ancestor

    //调用父类方法
    function callSuper() {
        var method = arguments.callee.caller,
            superMethod;
        if (method) {
            if (method._owner_) {
                superMethod = method._owner_.superclass.prototype[method._name_];
            } else if (method._wrapper_) {
                superMethod = method._wrapper_.superclass;
            } else {
                superMethod = emptyFn;
            }
            return superMethod.apply(this, arguments || emptyArgs);
        }
    }

    //暂时未用
    var staticUtil = {
        getStatic: function (name) {
            return this.constructor[name];
        }
    };

    //使用方法名调用父类方法
    var invokeSuper = (function () {
        var obj,
            superMethod,
            proxyResult = {
                execute: function () {
                    var result = superMethod.apply(obj, arguments || emptyArgs);
                    obj = null;
                    superMethod = null;
                    return result;
                }
            };

        function proxy(name) {
            try {
                superMethod = proxy.caller._owner_.superclass.prototype[name];
                if (!superMethod) {
                    throw (0);
                }
                obj = this;
                return proxyResult;
            } catch (e) {
                throw (new Error("[invokeSuper error]: the method " + name + "'s super is not exist!"));
            }
        }

        return proxy;
    })();

    //创建私有属性闭包
    function createPrivateClosure() {
        var privateProperties = {};
        return function (key, value) {
            if (value == undefined) {
                return privateProperties[key];
            } else {
                privateProperties[key] = value;
            }
        }
    }

    ////////////////////////////////////////////////////////////Class///////////////////////////////////////////////////////////
    //创建类
    function Class() {
        var clazz,
            options,
            initialize,
            interfaces,
            superclass,
            statics,
            mixin,
            fullName,
            className,
            path;
        if (arguments.length == 1) {
            options = arguments[0];
        } else if (arguments.length == 2) {
            fullName = arguments[0];
            path = fullName.split(".");
            className = path.pop();
            if (path.length > 0) {
                path = namespace(path.join('.'));
            } else {
                path = window;
            }
            options = arguments[1];
        } else {
            fullName = "";
            className = "";
        }
        if (options.hasOwnProperty('initialize')) {
            initialize = options['initialize'];
            delete options['initialize'];
        } else {
            initialize = function () {
            };
        }
        statics = options.hasOwnProperty('statics') ? options['statics'] : false;

        clazz = function () {
            var self = this,
            //私有属性的赋值、取值方法
                $ = function (key, value) {
                    var $method = arguments.callee,
                        caller = $method.caller,
                        callerClass = caller._owner_ || caller._wrapper_;
                    if (callerClass == $method._owner_) {
                        return $method.$$(key, value);
                    } else {
                        $method = $method._super_;
                        while ($method) {
                            if (callerClass == $method._owner_) {
                                break;
                            }
                            $method = $method._super_;
                        }
                    }
                    return $method.$$(key, value);
                };
            $.$$ = createPrivateClosure();
            $._owner_ = clazz;
            if (self.$) {
                $._super_ = self.$;
            }
            self.$ = $;

            //增加静态方法到实例本身
            statics && bindMethods(self, statics);
            initialize.apply(self, arguments);
        };
        initialize._wrapper_ = clazz;
        clazz._isClass_ = true;
        clazz._name_ = className;
        clazz._fullName_ = fullName;
        clazz._methods_ = [];
        clazz._interfaces_ = [];
        interfaces = options['interfaces'];
        mixin = options['mixin'];
        delete options['interfaces'];
        delete options['mixin'];

        //增加静态方法到类
        if (statics) {//TODO 火狐中name属性无法赋值
            for (var k in statics) {
                if (statics.hasOwnProperty(k)) {
                    clazz[k] = statics[k];
                }
            }
            delete options['statics'];
            addMethods(clazz, staticUtil);
        }

        //继承父类
        if (options.hasOwnProperty('superclass')) {
            superclass = options['superclass'];
            if (superclass) {
                inherit(clazz, superclass);
                superclass.prototype.callSuper || addMethods(clazz, {
                    callSuper: callSuper,
                    invokeSuper: invokeSuper
                });
                delete options['superclass'];
            } else {
                throw TypeError("the superclass of '" + fullName + "' is undefined!");
            }
        }

        //添加公有方法到类
        addMethods(clazz, options);

        //添加mixin方法到类
        if (mixin) {
            if (mixin.length && mixin.pop) {
                for (var i = 0; mixin[i] != undefined; i++) {
                    addMethods(clazz, mixin[i]);
                }
            } else {
                addMethods(clazz, mixin);
            }
            delete options['mixin'];
        }

        //实现、检查接口
        if (interfaces) {
            var _interfaces_ = clazz._interfaces_,
                _methods_ = clazz._methods_;
            if (!(interfaces instanceof Array)) {
                interfaces = [interfaces];
            }

            for (var i = 0, inter, methodName; interfaces[i] != undefined; i++) {
                inter = interfaces[i];
                for (var j = 0; inter[j] != undefined; j++) {
                    methodName = inter[j];
                    if (_methods_.indexOf(methodName) == -1) {
                        throw new Error("the method '" + methodName + "' need to implement in class '" + fullName + "'!");
                    }
                }
                _interfaces_.push(inter);

            }
        }
        if (className) {
            path[className] = clazz;
            path = arguments[0];
        }
        return clazz;
    }

    window.Class = Class;
    //命名空间
    Class.ns = namespace;
    //根据路径获取类
    Class.get = function (source) {
        try {
            var path = source.split('.'),
                obj = window[path[0]];
            if (path.length > 1) {
                for (var i = 1; path[i] != undefined; i++) {
                    obj = obj[path[i]];
                }
            }
            return obj;
        } catch (e) {
            throw new TypeError("no such class '" + source + "' is defined!");
        }
    };
    //为类设置别名
    Class.alias = function (source, alias) {
        var clazz,
            path = alias.split('.'),
            aliasName = path.pop(),
            aliasPath = path.join('.');
        if (typeof source == 'string') {
            clazz = Class.get(source);
        } else if (source._isClass_) {
            clazz = source;
        }
        if (clazz) {
            if (aliasPath) {
                namespace(aliasPath);
                Class.get(aliasPath)[aliasName] = clazz;
            } else {
                window[aliasName] = clazz;
            }
        }
    };
    ////////////////////////////////////////////////////////////Interface///////////////////////////////////////////////////////////
    function _interface(fullName, methods) {
        this.fullName = fullName;
        for (var i = 0; methods[i] != undefined; i++) {
            this[i] = methods[i]
        }
    }

    function Interface(fullName, methods) {
        if (methods instanceof Array) {
            var path = fullName.split("."),
                className = path.pop();
            if (path.length > 0) {
                path = namespace(path.join('.'));
            } else {
                path = window;
            }
            path[className] = new _interface(fullName, methods);
        } else {
            throw new Error("Interface '" + fullName + "' second must be Array!");
        }
    }

    window.Interface = Interface;
})();

代码还需改进，努力中