搜索:
首页 >> JavaScript >> Js高级编程 >> 《悟透JavaScript》之 甘露模型

《悟透JavaScript》之 甘露模型

2008-6-9 作者:李战 来源:软件真谛 投递文章

注意:如果您尚未阅读过原来那篇老文章《悟透JavaScript》,请先行阅读该文,以了解上下文关系。

在上面的示例中,我们定义了两个语法甘露,一个是Class()函数,一个是New()函数。使用Class()甘露,我们已经可以用非常优雅的格式定义一个类。例如前例中的:

var Employee = Class(Person,    //派生至Person类
    {
        Create: function(name, age, salary)
        {
            Person.Create.call(this, name, age);  //调用基类的构造函数
            this.salary = salary;
        },
        ShowMeTheMoney: function()
        {
            alert(this.name + " $" + this.salary);
        }
    });

这种类的写法已经和C#或Java的格式非常相似了。不过,其中调用基类的构造函数还需要用“Person.Create.call(this, name, age)”这样的方式来表达。这需要用到基类的类名,并要用call这种特殊的方式来传递this指针。这和C#的base()以及Java的super()那样的简介调用方式比起来,还需要进一步美化。

而New()函数的使用也不是很爽。前例中需要用“New(Employee, ["Steve Jobs", 53, 1234])”这样的方式来创建对象,其中第一个参数是,其他构造参数需要用数组包起来。这和JavaScript本来那种自然的“new Employee("Steve Jobs", 53, 1234)”比起来,丑陋多了。这也需要美化。

为了实现这些美化工作,我们需要回顾一下new一个对象的实质。前面我们说过:

    var anObj = new aClass();

相当于先创建一个空白对象anObj,然后将其作为this指针调用aClass()函数。其实,这个过程中还有一个关键步骤就是将aClass的prototype属性,赋值给anObj内置的prototype属性。尽管我们无法访问到anObj内置的prototype属性,但它却为对象提供了可以调用的方法。

由于前例中的Class()语法甘露实际上是构造了一个原型,并将这个原型挂在了相应的原型链上。由于它返回的是一个对象而不是函数,因此由它定义出来的Person和Employee类也都只是对象而不是函数,无法用new Person()或new Employee()这样的方式来创建对象。要创基于一个原型来创建对象,就需要借助New()语法甘露来中转这个原型。

那么,如果我们让Class()语法甘露返回一个函数而不是对象,不就可以用new Person()和new Employee()这种方式来创建对象了吗?而且,我们可为这个返回函数创建一个继承至相关原型链的原型对象,并设置到该函数的prototype属性。这样,我们用new方式创建这个类函数的对象时,就自然地继承了该类的原型了。

那么,我们让Class()语法甘露返回什么函数呢?因为Class()语法甘露返回的函数是用来创建对象的,当然应该返回该类的构造函数了,正好可以是类定义参数中的Create方法啊。这样一来,我们也无需在New()语法甘露中间接调用Create构造函数了,事实上New()语法甘露可以完全扔掉了。

    于是,我们就有了下面这个精简甘露模型的例子:

http://www.leadzen.cn/Books/WuTouJavaScript/1/JS24.htm

<script type="text/javascript">
    //定义类的语法甘露:Class()
    //最后一个参数是JSON表示的类定义
    //如果参数数量大于1个,则第一个参数是基类
    //第一个和最后一个之间参数,将来可表示类实现的接口
    //返回值是类,类是一个构造函数
    function Class()
    {
        var aDefine = arguments[arguments.length-1]; //最后一个参数是类定义
        if(!aDefine) return;
        var aBase = arguments.length>1 ? arguments[0] : object; //解析基类
        
        function prototype_(){}; //构造prototype的临时函数,用于挂接原型链
        prototype_.prototype = aBase.prototype;  //准备传递prototype
        var aPrototype = new prototype_();    //建立类要用的prototype
        
        for(var member in aDefine)  //复制类定义到当前类的prototype
            if(member!="Create")    //构造函数不用复制
                aPrototype[member] = aDefine[member];
if(aDefine.Create)  //若有构造函数
            var aType = aDefine.Create  //类型即为该构造函数
        else    //否则为默认构造函数
            aType = function()
            {
                this.base.apply(this, arguments);
            };
aType.prototype = aPrototype;   //设置类(构造函数)的prototype
        aType.Base = aBase;             //设置类型关系
        aType.prototype.Type = aType;   //为本类对象扩展一个Type属性
        return aType;   //返回构造函数作为类
    };
//根类object定义:
    function object(){}    //定义小写的object根类,用于实现最基础的方法等
    object.prototype.isA = function(aType)   //判断对象是否属于某类型
    {
        var self = this.Type;
        while(self)
        {
            if(self == aType) return true;
            self = self.Base;
        };
        return false;
    };
    
    object.prototype.base = function()  //调用基类构造函数
    {
        var Caller = object.prototype.base.caller;
        Caller && Caller.Base && Caller.Base.apply(this, arguments);
    };
    
    //语法甘露的应用效果:    
    var Person = Class      //默认派生自object基本类
    ({
        Create: function(name, age)
        {
            this.base();
            this.name = name;
            this.age = age;
        },
        SayHello: function()
        {
            alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
        }
    });
    
    var Employee = Class(Person,    //派生自Person类
    {
        Create: function(name, age, salary)
        {
            this.base(name, age);  //调用基类的构造函数
            this.salary = salary;
        },
        ShowMeTheMoney: function()
        {
            alert(this.name + " $" + this.salary);
        }
    });
var BillGates = new Person("Bill Gates", 53);
    var SteveJobs = new Employee("Steve Jobs", 53, 1234);
    BillGates.SayHello();
    SteveJobs.SayHello();
    SteveJobs.ShowMeTheMoney();
    
    var LittleBill = new BillGates.Type("Little Bill", 6); //用BillGate的类型建LittleBill
    LittleBill.SayHello();
    
    alert(BillGates.isA(Person));       //true
    alert(BillGates.isA(Employee));     //false
    alert(SteveJobs.isA(Person));       //true
</script>

这个精简甘露模型模拟出来的类更加自然和谐,而且比前面的甘露模型更加精简。其中的Class()函数虽然很简短,但却是整个模型的关键:

Class()函数将最后一个参数当作类定义,如果有两个参数,则第一个参数就表示继承的基类。如果多于两个参数,则第一个和最后一个之间的参数都可以用作类需要实现的接口声明,保留给将来扩展甘露模型使用吧。

使用Class()函数来定义一个类,实际上就是为创建对象准备了一个构造函数,而该构造函数的prototype已经初始化为方法表,并可继承上层类的方法表。这样,当用new操作符创建一个该类对象时,也就很自然地将此构造函数的原型链传递给了新构造的对象。于是,就可以采用象“new Person("Bill Gates", 53)”这样的语法来创建对象了。

1   2  3  4 下一页 尾 页
Tags:  class  javascript  模型 
相关文章
手机版 Js高级编程 Asp之家 Aspxhome.com
闽ICP备06017341号