• OOP。ES4新加了interface和class。惯用prototype+closure模拟各式OOP的老大多半恶向胆边生了。熟读SICP一类地下刊物的老大们也多半轻蔑滴抛出了杀手级名言：Object is just poor man’s closure。其实我挺欢迎这些特性。几乎每套 流行 框架都要用模拟OOP。不用流行类库的老大们写的第一段代码也多半如下：

• 继承用extends关键词。实现interface用implements关键词。常见的关键词static, final, override 通通支持。用惯Java和C#的老大可以笑了。
  
  
• 用关键词dynamic修饰的类里可以在runtime添加活删改属性。支持getter和setter，所以Ruby和C#的老大们可以兴奋了。通过关键字meta支持类似Ruby的method_missing()方法。这点相当不错。好多Ruby里流行的惯用法，尤其是用来实现DSL的惯用法可以派上用场了。
  
  
• 类的属性支持三种不同的修饰：DontDelete ：该属性固定，不能被动态移除； DontEnum：该属性不会在for(var p in object)的循环中出现； 和ReadOnly：该属性的值是常数。一旦确定，不能更该。普通class里的属性是DontDelete和DontEnum。用dynamic class申明的动态类的属性既非DontDelete，也非DontEnum。
  
  
• Generic function。也就是人们常说的multimethod，或者multiple dispatch method。这对用惯了C++操作符重载，CLOS和Dylan里generic method的老大们来说，正是重大利好消息啊。Generic function不是新鲜概念。1986年的OOPSLA会议上，一帮LISP Hacker提交了著名的论文CommonLoops – Merging Lisp and Object-Oriented Programming，里面正式提到了multimethod这个术语。据CLOS的作者Gregor Kiczales(拥护AOP的老大们应该觉得很亲切吧？)回忆，他的合作者Larry Masinter最早合成了multimethod这个词。流行的OO语言，比如Java/C#/C++/Python/Ruby什么的，通常只支持单分派方法。也就是说方法分派只与方法的调用者或者某一个参数（比如python里第一个参数self）有关。当我们看到caller.foo()时，我们就知道运行时调用的是对象caller里的方法foo()。可惜现实世界里的关系没有那么简单。Wikipedia用物体碰撞作例子。当我们想实现两类物体的碰撞时，到底在哪里实现我们的方法呢？比如说，我们想让飞船同陨石碰撞，到底把collide()方法放到spaceship里，还是放到asteroid里呢？如果要限定碰撞的类别呢？比如说友方飞船不能碰撞，但可以同敌方飞船碰撞呢？如果我们希望多个物体碰撞呢？如果我们的代码写好后，允许代码的用户添加新的物体和碰撞过程，该怎么办呢？Generic function就是用来解决这类多分派问题的。运行时调用generic function时，会根据该函数的*所有*参数决定分派对象。总的规则是越具体的类型占用越高的优先级。比如说foo(Number)比foo(Object)有更高的优先级，因为Number是Object的子类，比Object具体。另外，generic 函数里所有参数的分派权重一样，所谓的对称多分派。Groovy采用了不对称多分派。系统会先比较第一个参数。如果不能决定，再比较第二个。。。
  
  
  再看个常用的Visitor模式。我们用普通的表达式处理作例子。
  interface VisitableExpression{
      function accept(visitor: ExpressionVisitor); //是滴，ES4开始支持静态类型申明了
  }
  
  class AddExpression implements VisitableExpression{
      var lefOperand;
      var rightOperand;
  
      function accept(visitor:ExpressionVisitor){
          visitor.visitAddExpression(this);
      }
  }
  
  class IntExpression implements VisitableExpression{
      var value;
  
      function accept(visitor:ExpressionVisitor){
          visitor.visitIntExpression(this);
      }
  }
  
  interface ExpressionVisitor{
      function visitAddExpression(expression:VisitableExpression);
      function visitIntExpression(expression: :VisitableExpression);
  }

 这段代码问题不少。添加新的Visitor容易了。比如说求值Visitor，打印Visitor，或者后门注入Visitor。但添加新的ComplexExpression呢？这下每一个现有的Visitor都要改动。如果我想改动ExpressionVisitor里方法的签名呢—本来是件很美好的事，非被VisitableExpression的僵硬结构搞成丑闻。有了generic function，Visitor模式基本消失：

下面是课堂测验时间。用generic function改写下面的Builder模式（图取自GoF）：

• 类型系统。当然OOP里提到的class和interface也是类型系统的一部分（所谓的Nominal Type），但它们用的太广泛，就单独提出来聊了。
  • 加入了Record和Array类型。{a:int, b:char}是个Record。[int]是整数数组。是滴，ES4引入了int和char，不再像以前一样，浮点数和string包办一切了。不光如此，ES4也引入了Wrapper。比如boolean的wrapper是Boolean，double的wrapper是Double。这点俺其实不理解。当初Java区分primitive和wrapper类型是处于性能的考虑。ES4有必要这么做么？
    
    
  • Annotation。也就是前面看到的类型申明。比如var a:int；表示申明了类型为int的变量a。类型申明是可选的。函数参数，变量申明，函数返回值，常数申明时，都可以加上类型标注。这和普通的静态语言没有什么区别。这保证了ES3里没有类型申明的代码同ES4兼容。可选类型支持所谓的渐进式开发。我们可以从完全动态的程序开始，随着业务模型的稳定逐渐加入类型申明。编译期的类型系统也有助于IDE开发，编译器验证代码，文档生成。。。好处还是很多的。
    
    
  • 函数类型。function (this:C, int): boolean代表了C类里接受int参数，返回boolean的函数。这个有什么用呢？用ES3的时候，我们常常通过传递匿名函数来实现轻量级取代Strategy模式。问题是，所有匿名函数都是一个类型：Function。有了函数类型，我们就可以限制可以接受的函数了。这点想必也受Haskell/ML老大们的青睐。不过申明类型时写那么一长串也是自虐，所以类型定义粉墨登场：
    
    
• Type definition。类型定义类似C/C++里的typedef。我们用关键词type定义新的类型：Type IntComparator function(a: int, b:int): int。这段代码定义了一个新的函数类型IntComparator。如果我们写了一个给整数数组排序的函数sortInt(intArray: [int], comparator:IntComparator)，就不用担心接受一个比较字符串的函数了。ES4的typedef比C/C++的要强大。任何一个type申明都同时定义了该类型的元数据。元数据实现了meta-object interface，据在运行时通过反射读取。同时，定义的类型可以嵌套，但不允许递归（包括交互递归）。比如说我们定义类型Person：type Person = { name:{ last:string, first:string }, born:Date, spouse:* }。如果spouse的类型是Person，现在ES4环境运行时会陷入死循环，吃掉大量内存。将来多半编译器会报错。下图的run.exe就是ES4的执行环境。
  
  
  有了类型，怎么能没有子类型(subtype)呢？S <: T表示类型S是类型T的子类型。子类型有一堆判断规则。有兴趣地可以到白皮书第16页观赏。另外，有了类型，自然得考虑类型间的转换。于是两个强大的关键词，like（惯使Eiffel的老大可以笑了）和wrap粉墨登场。关键字like用于弱化的类型判别，颇有模式匹配的风格。可以申明var v: like { x: int, y: int }。那任何形如{int, int}类型的值都可以赋给变量v。比如说var p:Point, 那v = p是合法的赋值语句。like也可以做为操作符试用，比如说{a:10, b:20} is like Point会返回true。这好比数据的duck typing。我们不管值的类型是什么，只要关心它的“形状”。这样的话，我们既可以设定数据的结构，又不用被数据的类型限制得太死。关键词wrap同like类似，但把变量的类型强行“包装”被比较的类型。比如下面的代码里，变量v的类型就转换为{x:int, y:int}的类型：
  
              var v: wrap { x: int, y: int } = { x: 10, y: 20 }
             var w: { x: int, y: int } = v
  
  当作操作符用时，给定两变量v和t，如果v is t返回true，则 v wrap t返回变量v，不然如果v is like t为真，则返回一个新对象o, 使得v is o为真。再不然就抛出TypeError的异常罗。可以想象这两个操作符会衍生出许多灵活的应用。有兴趣的可以到这里看更多的例子。
  
  
• Parametric Types。也就是我们说的类型模板，或者泛型。比如下面的代码创建了一个容纳任何类型的Pair：class Pair.<T> {
      var first: T, second: T
  }
  
  函数，类，接口，和类型都支持参数类型。类里又能申明函数。卫生问题就出现了。比如下面的代码里，变量x的类型到底是什么？
  
  
  class Pair.<T> {
      var first: T, second: T;
      
      function f.<T>(){
          var x: T;
      }
  }
  所以这时用类型定义就派上用场了：
  
  
  class Pair.<T> {
      var first: T, second: T;
      
      Type XT = T;
      function f.<T>(){
          var x: XT;
      }
  }

下面插播一首诗：卫生问题在支持宏的语言里非常重要。《Beautiful Code》里专门有一章讨论它。强烈推荐。

发表于 @ 2007年12月13日 13:48:00|评论(loading...)|编辑