悟透JavaScript-原型真谛

<script>function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.getSelection?d.getSelection():'');void(keyit=window.open('http://www.365key.com/storeit.aspx?t='+escape(d.title)+'&u='+escape(d.location.href)+'&c='+escape(t),'keyit','scrollbars=no,width=475,height=575,left=75,top=20,status=no,resizable=yes'));keyit.focus();}</script>

正当我们感概万分时，天空中一道红光闪过，祥云中出现了观音菩萨。只见她手持玉净瓶，轻拂翠柳枝，洒下几滴甘露，顿时让JavaScript又添新的灵气。

观音洒下的甘露在JavaScript的世界里凝结成块，成为了一种称为“语法甘露”的东西。这种语法甘露可以让我们编写的代码看起来更象对象语言。

要想知道这“语法甘露”为何物，就请君侧耳细听。

在理解这些语法甘露之前，我们需要重新再回顾一下JavaScript构造对象的过程。

我们已经知道，用 var anObject = new aFunction() 形式创建对象的过程实际上可以分为三步：第一步是建立一个新对象；第二步将该对象内置的原型对象设置为构造函数prototype引用的那个原型对象；第三步就是将该对象作为this参数调用构造函数，完成成员设置等初始化工作。对象建立之后，对象上的任何访问和操作都只与对象自身及其原型链上的那串对象有关，与构造函数再扯不上关系了。换句话说，构造函数只是在创建对象时起到介绍原型对象和初始化对象两个作用。

那么，我们能否自己定义一个对象来当作原型，并在这个原型上描述类，然后将这个原型设置给新创建的对象，将其当作对象的类呢？我们又能否将这个原型中的一个方法当作构造函数，去初始化新建的对象呢？例如，我们定义这样一个原型对象：

view plain copy to clipboard print ?

1. var Person =  //定义一个对象来作为原型类   
2. {   
3.     Create: function(name, age)  //这个当构造函数   
4.     {   
5.         this.name = name;   
6.         this.age = age;   
7.     },   
8.     SayHello: function()  //定义方法   
9.     {   
10.         alert("Hello, I'm " + this.name);   
11.     },   
12.     HowOld: function()  //定义方法   
13.     {   
14.         alert(this.name + " is " + this.age + " years old.");   
15.     }   
16. };  

    var Person =  //定义一个对象来作为原型类
    {
        Create: function(name, age)  //这个当构造函数
        {
            this.name = name;
            this.age = age;
        },
        SayHello: function()  //定义方法
        {
            alert("Hello, I'm " + this.name);
        },
        HowOld: function()  //定义方法
        {
            alert(this.name + " is " + this.age + " years old.");
        }
    };

这个JSON形式的写法多么象一个C#的类啊！既有构造函数，又有各种方法。如果可以用某种形式来创建对象，并将对象的内置的原型设置为上面这个“类”对象，不就相当于创建该类的对象了吗？

但遗憾的是，我们几乎不能访问到对象内置的原型属性！尽管有些浏览器可以访问到对象的内置原型，但这样做的话就只能限定了用户必须使用那种浏览器。这也几乎不可行。

那么，我们可不可以通过一个函数对象来做媒介，利用该函数对象的prototype属性来中转这个原型，并用new操作符传递给新建的对象呢？

其实，象这样的代码就可以实现这一目标：

view plain copy to clipboard print ?

1. function anyfunc(){};           //定义一个函数躯壳   
2. anyfunc.prototype = Person;     //将原型对象放到中转站prototype   
3. var BillGates = new anyfunc();  //新建对象的内置原型将是我们期望的原型对象  

    function anyfunc(){};           //定义一个函数躯壳
    anyfunc.prototype = Person;     //将原型对象放到中转站prototype
    var BillGates = new anyfunc();  //新建对象的内置原型将是我们期望的原型对象

不过，这个anyfunc函数只是一个躯壳，在使用过这个躯壳之后它就成了多余的东西了，而且这和直接使用构造函数来创建对象也没啥不同，有点不爽。

可是，如果我们将这些代码写成一个通用函数，而那个函数躯壳也就成了函数内的函数，这个内部函数不就可以在外层函数退出作用域后自动消亡吗？而且，我们可以将原型对象作为通用函数的参数，让通用函数返回创建的对象。我们需要的就是下面这个形式：

这里的通用函数New()就是一个“语法甘露”！这个语法甘露不但中转了原型对象，还中转了构造函数逻辑及构造参数。

有趣的是，每次创建完对象退出New函数作用域时，临时的new_函数对象会被自动释放。由于new_的prototype属性被设置为新的原型对象，其原来的原型对象和new_之间就已解开了引用链，临时函数及其原来的原型对象都会被正确回收了。上面代码的最后一句证明，新创建的对象的constructor属性返回的是Object函数。其实新建的对象自己及其原型里没有constructor属性，那返回的只是最顶层原型对象的构造函数，即Object。

有了New这个语法甘露，类的定义就很像C#那些静态对象语言的形式了，这样的代码显得多么文静而优雅啊！

当然，这个代码仅仅展示了“语法甘露”的概念。我们还需要多一些的语法甘露，才能实现用简洁而优雅的代码书写类层次及其继承关系。好了，我们再来看一个更丰富的示例吧：

view plain copy to clipboard print ?

1. //语法甘露：   
2. var object =    //定义小写的object基本类，用于实现最基础的方法等   
3. {   
4.     isA: function(aType)   //一个判断类与类之间以及对象与类之间关系的基础方法   
5.     {   
6.         var self = this;   
7.         while(self)   
8.         {   
9.             if (self == aType)   
10.               return true;   
11.             self = self.Type;   
12.         };   
13.         return false;   
14.     }   
15. };   
16.   
17. function Class(aBaseClass, aClassDefine)    //创建类的函数，用于声明类及继承关系   
18. {   
19.     function class_()   //创建类的临时函数壳   
20.     {   
21.         this.Type = aBaseClass;    //我们给每一个类约定一个Type属性，引用其继承的类   
22.         for(var member in aClassDefine)   
23.             this[member] = aClassDefine[member];    //复制类的全部定义到当前创建的类   
24.     };   
25.     class_.prototype = aBaseClass;   
26.     return new class_();   
27. };   
28.   
29. function New(aClass, aParams)   //创建对象的函数，用于任意类的对象创建   
30. {   
31.     function new_()     //创建对象的临时函数壳   
32.     {   
33.         this.Type = aClass;    //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类   
34.         if (aClass.Create)   
35.           aClass.Create.apply(this, aParams);   //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似   
36.     };   
37.     new_.prototype = aClass;   
38.     return new new_();   
39. };   
40.   
41. //语法甘露的应用效果：       
42. var Person = Class(object,      //派生至object基本类   
43. {   
44.     Create: function(name, age)   
45.     {   
46.         this.name = name;   
47.         this.age = age;   
48.     },   
49.     SayHello: function()   
50.     {   
51.         alert("Hello, I'm " + this.name + ", " + this.age + " years old.");   
52.     }   
53. });   
54.   
55. var Employee = Class(Person,    //派生至Person类，是不是和一般对象语言很相似？   
56. {   
57.     Create: function(name, age, salary)   
58.     {   
59.         Person.Create.call(this, name, age);  //调用基类的构造函数   
60.         this.salary = salary;   
61.     },   
62.     ShowMeTheMoney: function()   
63.     {   
64.         alert(this.name + " ___FCKpd___2quot; + this.salary);   
65.     }   
66. });   
67.   
68. var BillGates = New(Person, ["Bill Gates", 53]);   
69. var SteveJobs = New(Employee, ["Steve Jobs", 53, 1234]);   
70. BillGates.SayHello();   
71. SteveJobs.SayHello();   
72. SteveJobs.ShowMeTheMoney();   
73.   
74. var LittleBill = New(BillGates.Type, ["Little Bill", 6]);   //根据BillGate的类型创建LittleBill   
75. LittleBill.SayHello();   
76.   
77. alert(BillGates.isA(Person));       //true   
78. alert(BillGates.isA(Employee));     //false   
79. alert(SteveJobs.isA(Person));       //true   
80. alert(Person.isA(Employee));        //false   
81. alert(Employee.isA(Person));        //true  

    //语法甘露：
    var object =    //定义小写的object基本类，用于实现最基础的方法等
    {
        isA: function(aType)   //一个判断类与类之间以及对象与类之间关系的基础方法
        {
            var self = this;
            while(self)
            {
                if (self == aType)
                  return true;
                self = self.Type;
            };
            return false;
        }
    };
    
    function Class(aBaseClass, aClassDefine)    //创建类的函数，用于声明类及继承关系
    {
        function class_()   //创建类的临时函数壳
        {
            this.Type = aBaseClass;    //我们给每一个类约定一个Type属性，引用其继承的类
            for(var member in aClassDefine)
                this[member] = aClassDefine[member];    //复制类的全部定义到当前创建的类
        };
        class_.prototype = aBaseClass;
        return new class_();
    };
    
    function New(aClass, aParams)   //创建对象的函数，用于任意类的对象创建
    {
        function new_()     //创建对象的临时函数壳
        {
            this.Type = aClass;    //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
            if (aClass.Create)
              aClass.Create.apply(this, aParams);   //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
        };
        new_.prototype = aClass;
        return new new_();
    };

    //语法甘露的应用效果：    
    var Person = Class(object,      //派生至object基本类
    {
        Create: function(name, age)
        {
            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)
        {
            Person.Create.call(this, name, age);  //调用基类的构造函数
            this.salary = salary;
        },
        ShowMeTheMoney: function()
        {
            alert(this.name + " ___FCKpd___2quot; + 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
    alert(Person.isA(Employee));        //false
    alert(Employee.isA(Person));        //true

 

“语法甘露”不用太多，只要那么一点点，就能改观整个代码的易读性和流畅性，从而让代码显得更优雅。有了这些语法甘露，JavaScript就很像一般对象语言了，写起代码了感觉也就爽多了！

令人高兴的是，受这些甘露滋养的JavaScript程序效率会更高。因为其原型对象里既没有了毫无用处的那些对象级的成员，而且还不存在constructor属性体，少了与构造函数间的牵连，但依旧保持了方法的共享性。这让JavaScript在追溯原型链和搜索属性及方法时，少费许多工夫啊。

我们就把这种形式称为“甘露模型”吧！其实，这种“甘露模型”的原型用法才是符合prototype概念的本意，才是的JavaScript原型的真谛！

想必微软那些设计AJAX架构的工程师看到这个甘露模型时，肯定后悔没有早点把AJAX部门从美国搬到咱中国的观音庙来，错过了观音菩萨的点化。当然，我们也只能是在代码的示例中，把Bill Gates当作对象玩玩，真要让他放弃上帝转而皈依我佛肯定是不容易的，机缘未到啊！如果哪天你在微软新出的AJAX类库中看到这种甘露模型，那才是真正的缘分！

 

view plain copy to clipboard print ?

1. function New(aClass, aParams)    //通用创建函数   
2.  {   
3.      function new_()     //定义临时的中转函数壳   
4.      {   
5.          aClass.Create.apply(this, aParams);   //调用原型中定义的的构造函数，中转构造逻辑及构造参数   
6.      };   
7.      new_.prototype = aClass;    //准备中转原型对象   
8.      return new new_();          //返回建立最终建立的对象   
9.  };   
10.     
11.  var Person =        //定义的类   
12.  {   
13.      Create: function(name, age)   
14.      {   
15.          this.name = name;   
16.          this.age = age;   
17.      },   
18.      SayHello: function()   
19.      {   
20.          alert("Hello, I'm " + this.name);   
21.      },   
22.      HowOld: function()   
23.      {   
24.          alert(this.name + " is " + this.age + " years old.");   
25.      }   
26.  };   
27.     
28.  var BillGates = New(Person, ["Bill Gates", 53]);  //调用通用函数创建对象，并以数组形式传递构造参数   
29.  BillGates.SayHello();   
30.  BillGates.HowOld();   
31.   
32.  alert(BillGates.constructor == Object);     //输出：true  

   function New(aClass, aParams)    //通用创建函数
    {
        function new_()     //定义临时的中转函数壳
        {
            aClass.Create.apply(this, aParams);   //调用原型中定义的的构造函数，中转构造逻辑及构造参数
        };
        new_.prototype = aClass;    //准备中转原型对象
        return new new_();          //返回建立最终建立的对象
    };
    
    var Person =        //定义的类
    {
        Create: function(name, age)
        {
            this.name = name;
            this.age = age;
        },
        SayHello: function()
        {
            alert("Hello, I'm " + this.name);
        },
        HowOld: function()
        {
            alert(this.name + " is " + this.age + " years old.");
        }
    };
    
    var BillGates = New(Person, ["Bill Gates", 53]);  //调用通用函数创建对象，并以数组形式传递构造参数
    BillGates.SayHello();
    BillGates.HowOld();

    alert(BillGates.constructor == Object);     //输出：true