Function和Object(2)

以下是Atlas中的关于Function和Object的源码,这两者基本构成了整个JavaScript的面向对象编程机制.
代码如下:

/*
    静态方法:Function.abstractMethod
    功能:不能直接调用,将抛出一个异常.
*/
Function.abstractMethod = function() {
    throw 'Abstract method should be implemented';
}

/*
    静态方法:Function.createCallback
    功能:创建并返回一个回调对象.调用时只是单纯的用传递context参数调用method方法.
*/
Function.createCallback = function(method, context) {
    return function() {
        return method(context);
    }
}

/*
    静态方法:Function.createCallback
    描述:创建委托对象.调用时,method方法中的this引用传入的instance,而不是调用者本身.
        其实就是返回一个函数对象
*/
Function.createDelegate = function(instance, method) {
    return function() {
        return method.apply(instance, arguments);
    }
}
//注:createCallback和createDelegate都返回函数对象,但是createCallback中声明的method内的this是window对象,
//而createDelegate中的this是传入的instance对象,仅此点不同.

//空函数
Function.emptyFunction = Function.emptyMethod = function() {
}

//扩展Function的常规属性和方法:以下的属性和方法,由funciton创建的对象都具备.)
/*
    函数名:getBaseMethod
    功能:获取基类的指定方法名的函数对象
*/
Function.prototype.getBaseMethod = function(instance, methodName, baseTypeName) {    
    var baseType = baseTypeName ? Function.parse(baseTypeName) : this.getBaseType();//
    var baseMethod = null;

if (baseType) {    
        var directBaseType = baseType;
        
        if (instance._baseMethods) {                              
            while (baseType) {              
                var methodKey = baseType.getName() + '.' + methodName; 
                var method = instance._baseMethods[methodKey];        
                if (method) {
                    return method;
                }
                baseType = baseType._baseType;
            }
        }
        
        if (!baseMethod) {
            return directBaseType.prototype[methodName];   
        }
    }
    
    return null;   
}

/**
    方法名:getBaseType
    功能:获取基类函数对象("类")
*/
Function.prototype.getBaseType = function() {
    return this._baseType;
}

/*
    方法名:getName
    功能:获取对象类名
*/
Function.prototype.getName = function() {
    return this._typeName;        
}

/**
    方法名:parse
    功能:解析获得函数对象实例(相当于C#中的通过反射获得对象的类,可以通过返回的函数对象用new创建类实例)
*/
Function.parse = function(functionName) {
    if (!Function._htClasses) {      
        Function._htClasses = {};    
    }
    var fn = Function._htClasses[functionName];.
    if (!fn) {                       
        try {
            eval('fn = ' + functionName);       
            if (typeof(fn) != 'function') { 
                fn = null;                    
            }
            else {
                Function._htClasses[functionName] = fn;
            }
        }
        catch (ex) {
        }
    }
    return fn;
}
//注:Function._htClasses是一个全局对象，它存放了一些通过"反射"类名机制获得的函数对象(不是实例对象).

/**
    方法名:_copyProps(私有)
    功能:拷贝传入对象的所有prototype属性和方法给当前函数对象.
*/
Function.prototype._copyProps = function(p_objFnc) {
    for (var strName in p_objFnc.prototype) {       
        var vValue = p_objFnc.prototype[strName];       
        if (!this.prototype[strName]) {                 
            this.prototype[strName] = vValue;           
        }
    }
}

/**
    方法名:_setBases(私有)
    功能:
*/
Function.prototype._setBases = function(p_objRoot) {
    if (p_objRoot._basePrototypePending) {  
        var astrPending = this.prototype._astrPendingInherits || [];
        for (var i=0; i < astrPending.length; i++) {
            var fncType = astrPending[i] instanceof Function ? astrPending[i] : Function.parse(astrPending[i]);

if (!fncType._parentBase) {
                fncType._parentBase= [];
            }
            fncType._parentBase.push(p_objRoot._typeName);
            
            if (!p_objRoot._childBase) {
                p_objRoot._childBase= [];
            }
            p_objRoot._childBase.push(fncType._typeName);

if (fncType && (this != fncType) && (!this.inheritsFrom(fncType)) && (!fncType.inheritsFrom(this)) && !fncType._sealed) {
                if (!fncType._typeName) {
                    fncType._typeName = typeof(astrPending[i])=="function" ? astrPending[i]._typeName : astrPending[i];
                }
                if (!this.bases) {              
                    this.bases = [];
                }
                this.bases.push(fncType);       
                fncType._setBases(p_objRoot);   
                this._copyProps(fncType);     
            }
        }
    }
    this._basePrototypePending = false; //
}

/**
    方法名:_callBaseConstructors(私有)
    功能:调用基类的构造器.
*/
Function.prototype._callBaseConstructors = function(p_objInstance, p_objArgs) {
    if (this.bases) {
        for (var i=0; i < this.bases.length; i++) {                    
            if (p_objArgs) {
                this.bases[i].apply(p_objInstance, p_objArgs);
            }
            else {
                this.bases[i].apply(p_objInstance);
            }
        }
    }
}

/**
    方法名:callBaseMethod
    功能:调用基类的方法.
*/
Function.prototype.callBaseMethod = function(instance, methodName, baseArguments) {
    var baseMethod = this.getBaseMethod(instance, methodName);      
    if (baseMethod) {
        if (!baseArguments) {   
            return baseMethod.apply(instance);  
        }
        else {
            return baseMethod.apply(instance, baseArguments);
        }
    }
    
    return null;
}

/**
    方法名:implementsInterface
    功能:判断是否实现了指定类型的接口.
*/
Function.prototype.implementsInterface = function(interfaceType) {
    this._setBases(this);
    var interfaces = this._interfaces;
    if (interfaces) {
        if (interfaces.contains(interfaceType)) {   
            return true;
        }
    }
    if (this.bases)        
    {
        for (var i=0; i < this.bases.length; i++)
        {
            if (this.bases[i].implementsInterface(interfaceType))
            {
                return true;
            }
        }
    }
    
    return false;
}

/**
    方法名:inheritsFrom
    功能:从指定基类名继承.
*/
Function.prototype.inheritsFrom = function(parentType) {
    if (parentType == this) {
        return true;
    }
    if (!this._basesPending) {
        this._basesPending = true;
        this._setBases(this);
        delete this._basesPending;
    }
    if (this.bases) {
        for (var i = 0; i < this.bases.length; i++) {
            if (this.bases[i].inheritsFrom(parentType)) {
                return true;
            }
        }
    }
    
    return false;
}

/**
    方法名:initializeBase
    功能:初始化基类.
*/
Function.prototype.initializeBase = function(instance, baseArguments) {    
    if (this._interfaces) {                           
        for (var i = 0; i < this._interfaces.length; i++) {
            this._interfaces[i].call(instance);       
        }
    }

if (!this._parentBase)        {
        this._parentBase = [];
        this._parentBase.push(this._typeName);
        this._childBase = [];
        this._childBase.push(this._typeName);
    } 
    
    this._setBases(this);
    this._callBaseConstructors(instance, baseArguments);   
    
    return instance;
}

/**
    方法名:isImplementedBy
    功能:
*/
Function.prototype.isImplementedBy = function(instance) {
    if (!instance) return false;
    var instanceType = Object.getType(instance);
    if (!instanceType.implementsInterface) {
        return false;
    }
    return instanceType.implementsInterface(this);
}

/**
    方法名:isInstanceOfType
    功能:判断传入的对象是否是本类类型.
*/
Function.prototype.isInstanceOfType = function(instance) {
    if (typeof(instance) == 'undefined' || instance == null) {
        return false;
    }

if (instance instanceof this) {
        return true;
    }
    
    var instanceType = Object.getType(instance);
    if (instanceType == this) {
        return true;
    }
    if (!instanceType.inheritsFrom) {
        return false;
    }
    return instanceType.inheritsFrom(this);
}

/**
    方法名:registerBaseMethod
    功能:注册基类方法.
*/
Function.prototype.registerBaseMethod = function(instance, methodName) {
            
    if (!instance._baseMethods) {   
        instance._baseMethods = { };
    }
    var methodKey = this.getName() + '.' + methodName; 
    //instance[methodName]等价于instance.methodName
    instance._baseMethods[methodKey] = instance[methodName];
}

/**
    方法名:createInstance
    功能:创建类实例对象.
*/
Function.createInstance = function(type) {
    if (typeof(type) != 'function') {
        type = Function.parse(type);    
    }
    
    return new type();  
}

/**
    常规方法:registerClass
    功能:注册类
*/
Function.prototype.registerClass = function(typeName, baseType, interfaceType) {
    //this._typeName自身类名
    //this._baseType:单继承
    //this._interfaces:多接口
        
    if (window.__safari) {
        this.prototype.constructor = this;
    }
    this._typeName = typeName;  
    //
    if (baseType) {                 
        this._baseType = baseType;  
        if (!(baseType instanceof Array)) { 
            baseType = [baseType];
        }
                
        if (!this.prototype._astrPendingInherits) {
            this.prototype._astrPendingInherits = [];
        }
        for (var i=0; i < baseType.length; i++) {     
            this.prototype._astrPendingInherits.push(baseType[i]);
        }
        this._basePrototypePending = true;          
    }
   
    if (interfaceType) {
        this._interfaces = [];
        for (var i = 2; i < arguments.length; i++) {
            interfaceType = arguments[i];
            this._interfaces.push(interfaceType);
        }
    }

return this;
}

/**
    常规:registerAbstractClass
    功能:注册抽象类.
*/
Function.prototype.registerAbstractClass = function(typeName, baseType) {
    this.registerClass.apply(this, arguments);
    this._abstract = true;     
    return this;
}

/**
    常规:registerSealedClass
    功能:注册密封类.
*/
Function.prototype.registerSealedClass = function(typeName, baseType) {
    this.registerClass.apply(this, arguments);
    this._sealed = true;
    return this;
}

/**
    常规方法:registerInterface
    功能:注册接口
*/
Function.prototype.registerInterface = function(typeName) {
    this._typeName = typeName;
    this._interface = true; 
    this._abstract = true;  
    this._sealed = true;
    
    return this;
}
/**
    静态方法:registerNamespace
    功能:注册命名空间.
*/
var registerNamespace = Function.registerNamespace = function(namespacePath) {
    var rootObject = window;                    
    var namespaceParts = namespacePath.split('.');
    for (var i = 0; i < namespaceParts.length; i++) {
        var currentPart = namespaceParts[i];
        if (!rootObject[currentPart]) {                 
            rootObject[currentPart] = new Object();  
        }
        rootObject = rootObject[currentPart];    
    }
}

Function._typeName = 'Function';    //Function类的类名.    
    
//返回对象的类函数对象(是函数(类),而不是实例对象)
Object.getType = function(instance) {
    var ctor = instance.constructor;    //获取对象的构造器
    if (!ctor || (typeof(ctor) != "function") || !ctor._typeName) {//如果构造器为空/构造器不是函数对象/构造器没有类名
        return Object;
    }
    return instance.constructor;
}

//获取实例对象的类名
Object.getTypeName = function(instance) {
    return Object.getType(instance).getName();//获取实例对象的类(函数对象)后,再调用Function定义的getName方法
}

//由于Object是所有JavaScript对象的基类,因此它定义的方法和属性一并附加到了对象上
Object._typeName = 'Object';

以下开始逐一分析Atlas对Function与Object两大基础对象的扩展,以及如何架构Atlas的OO机制的.
1)名称空间namespace
面向对象的一个特点是具有名称空间这个概念.JavaScript没有内建支持此概念,但是,说到底,名称空间也就是一个将一些同名类按功能模块区分的一个"名称"罢了.想在JavaScript中实现"名称空间"这个概念其实相当简单.
首先让我们来测试几个使用"名称空间"的示例,如下:

Function.registerNamespace("MySpace1");
MySpace1.MyClass = function(){
    this.show = function(str){
        alert("MySpace1:"+str);
    }
}
Function.registerNamespace("MySpace1.MySpace2");
MySpace1.MySpace2.MyClass = function(){
    this.show = function(str){
        alert("MySpace1.MySpace2:"+str);
    }
}

var a = new MySpace1.MyClass();
var b = new MySpace1.MySpace2.MyClass();
a.show(typeof(MySpace1));                   //MySpace1 is object
b.show(typeof(MySpace1.MyClass));           //MySpace1.MyClass is function 
        
    </script>

   这里我把Atlas的实现"名称空间"的代码复制过来,并单独应用.从代码可知,当把名称空间字符串(以"."分隔)调用Function.registerNamespace方法时,第一行代码"var rootObject = window"是关键所在.所谓"名称空间",其实也是一个实例对象,如这里的"MySpace1"经过注册后,它是第一层"名称空间",看这段代码"rootObject[currentPart] = new Object();",在i为0时,这行代码等价于"window.全局属性 = new Object()".
   一言概之,Atlas实现的"名称空间",其实是一个个"new Object()",是一个个object对象,而"类",测试这些object对象的属性(函数对象),创建实例对象时,就是用"new 名称空间.函数对象(...)".
   顶级的"名称空间"对象是window下的全局对象,顶级"名称空间"下的次级的"名称空间"以及"类",则都是它的不同层次的属性对象.
从"a.show(typeof(MySpace1)); //MySpace1 is object b.show(typeof(MySpace1.MyClass)); //MySpace1.MyClass is function "这两行代码,我们可以看到,MySpace1是object实例对象,而MySpace1.MyClass则是function函数对象,这里,实例对象的属性竟然可以是"类",这也是JavaScript与其他语言区别很大的地方.

2)接口interface
接口只是某一方面的功能描述,或者说是约束,让继承接口的类必须实现接口定义的属性和方法.    首先让我们来看一段"定义接口"的代码:

IArray是一个理解上的"接口",单纯从代码上看,它就是一个函数对象.但是通过"registerInterface"后,IArray具备了一些接口的专有属性,具备了"接口"的特征,如"IArray._interface = true"等.(重要的一点:JavaScript是无法实现代码约束性很强的功能,很多东西,都需要编写者从"自觉遵守"的角度去做)

2)抽象类
Function.prototype.registerAbstractClass = function(typeName, baseType) {
   this.registerClass.apply(this, arguments);
   this._abstract = true; //是否是抽象类的标志 return this;
}

3)密封类
Function.prototype.registerSealedClass = function(typeName, baseType) {
   this.registerClass.apply(this, arguments); //密封类还是类,需要注册类
   this._sealed = true; //是否密封类的标志 return this;
}

4)类
类,如我上节所述,JavaScript中的"类",其实是函数对象,是经typeof(f)返回function类型的对象.
在JavaScript中创建"类"是很简单的事,只要写一个函数即可,因为函数对象就是"类".写一个"类"容易,但是单纯的JavaScript的"类",不直接支持很多OO特性,如继承\接口实现\调用基类方法等.要将"类"组织管理好,就要下一番工夫了.
以下是Atlas注册一个类的方法

nbsp;

posted on 2006-10-02 11:13 想那风霜雪阅读(574) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

无梦空间

导航

公告

Function和Object(2)