Class.create Vs Object.extend

阅读更多

Prototype在1.6之前的实现一个继承的操作的时候都是采用Object.extend的方式。Object.extend的实现原理是先创建出父类的对象并将子类中的方法复制到这个对象中去，这样做可以比较轻松的实现一个子类到父类的upcasting。但是这样也会存在一个问题，就是子类无法在自己的构造函数中调用父类的构造函数，也就是说无法实现super这样的操作。

1.6以前的Object.extend的实现代码:

   
   
   
   

    
    
    
    

     
     
     
     

      
      
      
      Object.
      
      
      
      extend = 
      
      
      
      function
      
      
      
      (destination, source
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      for 
      
      
      
      (
      
      
      
      var property 
      
      
      
      in source
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          destination
      
      
      
      [property
      
      
      
      ] = source
      
      
      
      [property
      
      
      
      ];
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      return destination;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      } 
     
     
     
     
   
   
   
   

1.6的Prototype中改写了关于继承的实现，Class.create新增加了一种模式的调用，Class.create([BassClass], {});

Prototypejs.org提供的Class.create新的实例：

   
   
   
   

    
    
    
    

     
     
     
     

      
      
      
      var Animal = 
      
      
      
      Class.
      
      
      
      create
      
      
      
      (
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
        initialize: 
      
      
      
      function
      
      
      
      (
      
      
      
      name, sound
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      this.
      
      
      
      name  = 
      
      
      
      name;
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      this.
      
      
      
      sound = sound;
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      },
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
        speak: 
      
      
      
      function
      
      
      
      (
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      alert
      
      
      
      (
      
      
      
      this.
      
      
      
      name + 
      
      
      
      " says: " + 
      
      
      
      this.
      
      
      
      sound + 
      
      
      
      "!"
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      }
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      // subclassing Animal
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      var Snake = 
      
      
      
      Class.
      
      
      
      create
      
      
      
      (Animal, 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
        initialize: 
      
      
      
      function
      
      
      
      ($super, 
      
      
      
      name
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          $super
      
      
      
      (
      
      
      
      name, 
      
      
      
      'hissssssssss'
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      }
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      var ringneck = 
      
      
      
      new Snake
      
      
      
      (
      
      
      
      "Ringneck", 
      
      
      
      "hissssssss"
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      ringneck.
      
      
      
      speak
      
      
      
      (
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      //-> alerts "Ringneck says: hissssssss!" 
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
   
   
   
   

在这个实例中我们看到了$super这个新增加的函数，通过$super方法我们可以调用父类的方法。再来看一下最新的Prototype 1.6中的Class.create的实现：

   
   
   
   

    
    
    
    

     
     
     
     

      
      
      
      /* Based on Alex Arnell's inheritance implementation. */
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      var 
      
      
      
      Class = 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
        create: 
      
      
      
      function
      
      
      
      (
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      var parent = 
      
      
      
      null, properties = $A
      
      
      
      (arguments
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      if 
      
      
      
      (Object.
      
      
      
      isFunction
      
      
      
      (properties
      
      
      
      [
      
      
      
      0
      
      
      
      ]
      
      
      
      )
      
      
      
      )
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            parent = properties.
      
      
      
      shift
      
      
      
      (
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      function klass
      
      
      
      (
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
      
      
      
      
      this.
      
      
      
      initialize.
      
      
      
      apply
      
      
      
      (
      
      
      
      this, arguments
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          Object.
      
      
      
      extend
      
      
      
      (klass, 
      
      
      
      Class.
      
      
      
      Methods
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          klass.
      
      
      
      superclass = parent;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          klass.
      
      
      
      subclasses = 
      
      
      
      [
      
      
      
      ];
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      if 
      
      
      
      (parent
      
      
      
      ) 
      
      
      
      {
     
     
     
     
    
    
    
    

     
     
     
     
      
      
      
      
      var subclass = 
      
      
      
      function
      
      
      
      (
      
      
      
      ) 
      
      
      
      { 
      
      
      
      };
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            subclass.
      
      
      
      prototype = parent.
      
      
      
      prototype;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            klass.
      
      
      
      prototype = 
      
      
      
      new subclass;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            parent.
      
      
      
      subclasses.
      
      
      
      push
      
      
      
      (klass
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      for 
      
      
      
      (
      
      
      
      var i = 
      
      
      
      0; i < properties.
      
      
      
      length; i++
      
      
      
      )
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            klass.
      
      
      
      addMethods
      
      
      
      (properties
      
      
      
      [i
      
      
      
      ]
      
      
      
      );
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      if 
      
      
      
      (!klass.
      
      
      
      prototype.
      
      
      
      initialize
      
      
      
      )
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
            klass.
      
      
      
      prototype.
      
      
      
      initialize = Prototype.
      
      
      
      emptyFunction;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
          klass.
      
      
      
      prototype.
      
      
      
      constructor = klass;
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
       
     
     
     
     
    
    
    
    

     
     
     
     
    
      
      
      
      return klass;
     
     
     
     
    
    
    
    

     
     
     
     
  
      
      
      
      }
     
     
     
     
    
    
    
    

     
     
     
     

      
      
      
      }; 
     
     
     
     
   
   
   
   

可以看到最新的继承实现将父类暂存中superclass，这样在子类中通过$super调用父类的方法时，实际上调用的是this.superclass中的方法。

在开发Glove.Widget时候曾经就为没有super方法犯愁过，现在1.6有了新的继承模式Glove.Widget就不用像以前那样丑陋的实现super的功能了。明天开始考虑Glove.Widget基于Prototype1.6的重构。