×
13518219792

建站动态

根据您的个性需求进行定制 先人一步 抢占小程序红利时代

Ruby2.0发布新特性介绍

本月24日（也就是明天）Ruby 2.0终于就要发布了。

成都创新互联公司主营进贤网站建设的网络公司,主营网站建设方案,成都App制作,进贤h5成都小程序开发搭建,进贤网站营销推广欢迎进贤等地区企业咨询

Ruby核心团队的卜部昌平桑昨天在一个内部学习会上的presentation，介绍了Ruby 2.0所包含的一些新特性。

（本文内容选译自该幻灯片。）

为什么有Ruby 2.0？

Ruby 2.0有什么新鲜的？

什么不是Ruby 2中的新鲜货

也就是说，

Ruby 2.0的新句法

关键字参数（Keyword arguments）

下面的代码在1.x中能够正常工作：

  

 
 
 
    
  
  
  
  1. obj.method "with", :lots => "of",  
    2. 
  
  
  
  2.                    :args => "in",  
    3. 
  
  
  
  3.                    :hash => "form" 
    4.

但是，问题出在哪呢？

问题是在定义该方法的时候： （Mort注：在Ruby 1.x中，只能将多个带符号名称的参数作为一个Hash来传递给方法。要为参数指定默认值，实现起来就很累赘，参见如下代码）

  

 
 
 
    
  
  
  
  1. def obj.method(arg, hash)  
    2. 
  
  
  
  2.   lots = Hash[:lots] || "default" 
    3. 
  
  
  
  3.   args = Hash[:args] || "another" 
    4. 
  
  
  
  4.   hand = Hash[:by hand] || "annoying" 
    5. 
  
  
  
  5.   ...  
    6. 
  
  
  
  6. end 
    7.

注意到代码中错误的Hash[:by hand]——手写代码是错误产生的根源！

从2.0开始，Ruby将引入关键字参数：

  

 
 
 
    
  
  
  
  1. def obj.method(a, b = 1, c: 1, d: 2) 
    2.

其中a为固定参数，b为可选参数，c、d则为关键字参数。这样，局部变量a、b、c和d都将被恰当地赋值。

在调用函数时，原有的调用方式无需更改。

Mort注：虽然幻灯片里没有写，传统的基于Hash参数的调用方法是这个样子的

  

 
 
 
    
  
  
  
  1. obj.method("foo", :c => 2, :d => 3) 
    2.

现在Ruby 2.0同时也支持直接采用关键字参数的调用方法：（Python程序员一定会觉得这种语法更亲切）

  

 
 
 
    
  
  
  
  1. obj.method("foo", c: 2, d: 3) 
    2.

更详细的示例，可以参考这里：

http://brainspec.com/blog/2012/10/08/keyword-arguments-ruby-2-0/

其他细微的句法改进

  
 
 
    
   
  
  
  1. %i(foo bar baz) # => [:foo, :bar, :baz] 
    2.

Ruby 2.0的核心性能改进

require的改进

Backtrace惰性生成

Flonum类

Mort注：图片懒得搬运了……请参见原幻灯片。

GC（Garbage Collection）

Ruby 2.0的新核心特性：#1 调试工具

DTrace支持

TracePoint支持

GC stats

Ruby 2.0的新核心特性：#2 核心库

细粒度的异步中断处理

Ruby的执行有时会因为各种原因而中断，例如，超时。

Ruby 2.0提供了细粒度的异步中断处理方案：

  
 
 
    
   
  
  
  1. Thread.async_interrupt_timing Timeout::Error => :defer do 
    2. 
   
  
  
  2.   timeout(rand()) do 
    3. 
   
  
  
  3.     begin 
    4. 
   
  
  
  4.       Thread.async_interrupt_timing Timeout::Error => :immediate do 
    5. 
   
  
  
  5.         setup  
    6. 
   
  
  
  6.         handle  
    7. 
   
  
  
  7.         ...  
    8. 
   
  
  
  8.       end 
    9. 
   
  
  
  9.     ensure 
    10. 
   
  
  
  10.       teardown  
    11. 
   
  
  
  11.     end 
    12. 
   
  
  
  12.   end 
    13. 
   
  
  
  13. end 
    14.

模块前插

有时候你想要给一个方法添加需要的安装或拆解代码，而相应的部分却定义在别处。

  
 
 
    
   
  
  
  1. module ActiveRecordHelper  
    2. 
   
  
  
  2.   def save  
    3. 
   
  
  
  3.     ???  
    4. 
   
  
  
  4.   end 
    5. 
   
  
  
  5. end 
    6.

该如何去做呢？在Ruby 2.0中，你可以：

  
 
 
    
   
  
  
  1. class Foo < AR::Base  
    2. 
   
  
  
  2.   prepend AR::Helper  
    3. 
   
  
  
  3.  
    4. 
   
  
  
  4.   def save  
    5. 
   
  
  
  5.     bar  
    6. 
   
  
  
  6.   end 
    7. 
   
  
  
  7. end 
    8. 
   
  
  
  8.  
    9. 
   
  
  
  9. module AR::Helper  
    10. 
   
  
  
  10.   def save  
    11. 
   
  
  
  11.     foo  
    12. 
   
  
  
  12.     super 
    13. 
   
  
  
  13.     baz  
    14. 
   
  
  
  14.   end 
    15. 
   
  
  
  15. end 
    16. 
   
  
  
  16.  
    17. 
   
  
  
  17. Foo.new.save  
    18.

这避开了Rails中的所谓“别名方法链（alias method chain）”的困扰。AMC什么的已经不再必要了。

惰性枚举器

Ruby的foo.bar.baz. ...风格（所谓的“流水作业”）有时会传递许多并不必要的临时对象，而这些理论上都可以通过惰性求值来避免。

  
 
 
    
   
  
  
  1. File.open(path) {|fp|  
    2. 
   
  
  
  2.     fp.each_line. \  
    3. 
   
  
  
  3.     select {|line| # 生成了临时数组  
    4. 
   
  
  
  4.     /regexp/ =~ line  
    5. 
   
  
  
  5.     }. \  
    6. 
   
  
  
  6.     each_with_index.map {|line, no| # 生成了临时数组  
    7. 
   
  
  
  7.     sprintf("%d: %s\n", no, line)  
    8. 
   
  
  
  8.     }. \  
    9. 
   
  
  
  9.     first(10).each {|str| # 生成了临时数组  
    10. 
   
  
  
  10.         puts(str)  
    11. 
   
  
  
  11.     }  
    12. 
   
  
  
  12. } 
    13. 
  
 
 
  
 
 
    
   
  
  
  1. File.open(path) {|fp|  
    2. 
   
  
  
  2.     fp.each_line.lazy \  
    3. 
   
  
  
  3.     select {|line| # 没有临时数组产生  
    4. 
   
  
  
  4.     /regexp/ =~ line  
    5. 
   
  
  
  5.     }. \  
    6. 
   
  
  
  6.     each_with_index.map {|line, no| # 没有临时数组产生  
    7. 
   
  
  
  7.     sprintf("%d: %s\n", no, line)  
    8. 
   
  
  
  8.     }. \  
    9. 
   
  
  
  9.     first(10).each {|str| # 没有临时数组产生  
    10. 
   
  
  
  10.         puts(str)  
    11. 
   
  
  
  11.     }  
    12. 
   
  
  
  12. } # 甚至在到达EOF之前都不读取数据 
    13.

一个有趣的应用实例：无穷枚举器。

  
 
 
    
   
  
  
  1. # Leibniz formula for π  
    2. 
   
  
  
  2. (0..Float::INFINITY).lazy.map {|i|  
    3. 
   
  
  
  3.     ((-1) ** i) / (2*i + 1).to_f  
    4. 
   
  
  
  4. }.take(65536).reduce(:+) * 4 
    5.

其他的新方法

Mort注：更多关于Ruby 2.0核心特性的介绍，参考

Ruby 2.0标准库的改进

总结

什么不是Ruby 2中的新鲜货

也就是说，

Don’t be afraid. Use Ruby today!

视频：AKB48 - Ruby

原文链接：http://www.soimort.org/posts/140/


网站名称：Ruby2.0发布新特性介绍
网站路径：http://cdbrznjsb.com/article/cojddod.html

其他资讯

让你的专属顾问为你服务