《悟透JavaScript》之 甘露模型

注意：如果您尚未阅读过原来那篇老文章《悟透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)”这样的语法来创建对象了。