Ruby都从Perl那继承了什么？

最近看了看Perl，主要是想看看Ruby都从Perl那拿来了些什么。同时，也是我学习Perl的一篇笔记。

为什么大家都是Perl的代码丑陋，是什么导致了Perl程序晦涩难懂，Ruby中又是如何取舍这些元素的呢？我认为Perl社区追求更少代码的风气助长了大量使用预设变量的风气，从而导致了Perl代码的晦涩。

下面的每个Perl的例子总伴有Ruby的对照。

Perl的理念-条条大道通罗马「There is more than one way to do it」。

都说Perl简单、“万能”、快速、丑陋，Ruby咋就这么慢呢？

Perl的前身语言：C, awk, sed, sh, 以系统管理为目标, 强调使用性而不是美观。

• 断句

Perl的语句是以分号";"作为分隔，而Ruby是以换行。所以Ruby的代码中鲜见分号。

• 输入输出

Ruby的输出(print)似乎就是从Perl那直接拿过来的：

#!perl print "hi, Pope." 

#!ruby print "hi, Pope." 

但字符串的内插就有所不同了。

Perl中可以这样实现字符串的变量替换：

#!perl my $name = "Pope"; print "hi, $name/n"; 

而Ruby中是将变量用#{}包裹起来：

#!ruby name = "Pope" print "hi, #{name}." 

Perl的输入使用<STDIN>。不过，大家一般用钻石运算符(diamond operator)"<>":

#!perl print "please enter your name:"; my $name = <>; print "hello, $name/n"; 

在Ruby中，一般用STDIN.gets或者gets：

#!ruby print "please enter your name:"; name = gets; print "hello, #{name}/n"; 

• 字符串

Perl的字符串可以用双引号括起来,也可以用qq//,qq||,qq{},qq后跟任意成对的符号.

#!perl my $s1 = "Pope"; my $s2 = qq/Pope/; my $s3 = qq|Pope|; my $s4 = qq{Pope}; 

Ruby也学来了,用%q或%Q加任意成对的符号.不过,Rubyist喜欢用%q[].(附带说明一下%q和%Q的区别,用%q来括就好象是用单引号,而%Q如同双引号.单双引号是不同的喔!)

#!ruby s1 = "Pope"; s2 = %Q/Pope/; s3 = %Q|Pope|; s4 = %Q{Pope}; 

• 数组

在Perl中，数组变量是以@符开头,用小括号把值括起来.

 

#!perl my @array = (1, 2, 3); 

用qw也行:

#!perl my @array = qw/1 2 3/; 

Ruby中是用中括号，也可用%w。

#!ruby array = [1, 2, 3] 

Perl和Ruby的数组都可以自动扩充。数组中没有指定值的元素会被Perl设为undef，而Ruby中是nil。在Perl中计算数组长度是用$#array+1，其中$#array是数组array的最后一个索引值；而Ruby中就比较简单，可以用size或者length。

两者都有切片。

#!perl my @array = (0...10); my @array2 = @array[2...4]; print @array2; # 234 

#!ruby array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; array2 = array[2 .. 4]; print array2; # 234 

Ruby中还可以用Array.slice：

#!ruby array2 = array.slice(2 .. 4); 

Perl用sort对数组排序。

#!perl my @array = qw/45 33 75 21 38 69 46/; @array = sort { $a <=> $b } @array; 

（$a和$b是Perl的预设常量，在排序时被用来作为两两取出的两个数字。Ruby中就不必这样，Ruby是用块中的变量来实现array.sort!{|a, b| a <=> b}）

或者直接sort

#!perl my @array = qw/45 33 75 21 38 69 46/; @array = sort @array; 

#!ruby array = %w/45 33 75 21 38 69 46/; array.sort!; 

Ruby还学来了join：

#!perl my @array = qw/-4 45 -33 8 75 21 -15 38 -69 46/; print join ',', @array; # -4,45,-33,8,75,21,-15,38,-69,46 

#!ruby array = %w/-4 45 -33 8 75 21 -15 38 -69 46/ print array.join ',' # -4,45,-33,8,75,21,-15,38,-69,46 

还有map：

#!perl my @array = map { sqrt($_)*10 } qw/45 33 8 75 21 15 38 69 46/; 

Ruby中map 和collect同义：

#!ruby array = %w/45 33 8 75 21 15 38 69 46/.map{|x| Math.sqrt(x)*10} 

以及grep：

#!perl my @array = qw/6 -4 8 12 -22 19 -8 42/; my @positive = grep {$_ > 0} @array; 

当然Ruby中也有grep，不过在这里用select比较方便：

#!ruby array = %w/6 -4 8 12 -22 19 -8 42/ positive = array.select{|x| x.to_i > 0} 

push/pop

#!perl my @array = qw{first second third}; push @array, 'fourth'; print @array; # first second third fourth pop @array; print @array; # first second third

#!ruby array = %w{first second third} array.push 'fourth' print array; # first second third fourth array.pop print array; # first second third  

shift/unshift

#!perl my @array = (1...10); shift @array; # 我把1拿掉了 unshift @array, 0; # 現在补上0 print @array; # 0 2 .. 10 

#!ruby array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] array.shift array.unshift 0 # 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 

还有很多，都比较简单，这就不一一列举了。

• 基本控制结构

Perl有很多C的遗迹，比如Perl没有Boolean型的true和false，所以在判断真假时就比较麻烦。在Perl中，0、空字串、一个内容为"0"的字串和一个undef的值都是假。

而在Ruby中除了false和nil，其它一切皆为真。

• 分支判断

Perl中用if..else..来做分支判断。

#!perl my $num = <STDIN>; chomp($num); if ($num < 5) { print "small"; } else { print "big"; } 

在各种语言中的if语句几乎都一样。但注意Ruby中更喜欢像英语那样书写代码，所以不喜欢用{}。

#!ruby num = gets if num.to_i < 5 print "small" else print "big" end 

与if相对的，还有unless。上面的程序用unless改写就成了这样：

#!perl my $num = <STDIN>; chomp($num); unless ($num >= 5) { print "small"; } else { print "big"; } 

#!ruby num = gets unless num.to_i >= 5 print "small" else print "big" end 

当然，惜字如金的Perl程序员发明了后缀判断：

#!perl my $num = 3; $num++ if ($num < 5); print $num # 4 

毫无疑问，这么好的东西Ruby当然要学过来。

#!ruby num = 3; num = num + 1 if num < 5 print num # 4 

让Ruby程序员骄傲地是，Ruby中有switch， 而Perl没有提供switch。

#!ruby case "This is a character string." when "some value" puts "Branch 1" when "some other value" puts "Branch 2" when /char/ puts "Branch 3" else puts "Branch 4" end 

• 循环

循环当然少不了while。

#!perl my $num = 1; my $result = 1; while ($num <= 10) { $result*=$num; $num = $num + 1; } print $result; # 3628800 

#!ruby num = 1 result = 1 while num <= 10 result *= num; num = num + 1; end print result # 3628800 

类似if/unless这对，while也有until。

#!perl my $num = 1; my $result = 1; until ($num > 10) { $result*=$num; $num = $num + 1; } print $result; # 3628800 

#!ruby num = 1 result = 1 until num > 10 result *= num; num = num + 1; end print result # 3628800 

可能是受C影响太大，Perl中居然可以像C一样写for！

#!perl my $result = 1; for (my $num = 1; $num <= 10; $num = $num + 1) { $result *= $num; } print $result; # 3628800 

不过Perl程序员更喜欢简洁的写法：

#!perl my $result = 1; for (1...10) { $result *= $_ } print $result; # 3628800 

#!ruby result = 1 for x in (1 .. 10) do result *= x end print result # 3628800 

除了for，Ruby中用来表达循环的方式还有很多，参见 The Ruby Way的1.2.6节。

#!ruby list = [1, 2, 3] # Loop 1 (while) i=0 while i < list.size do print "#{list[i]} " i += 1 end # Loop 2 (until) i=0 until i == list.size do print "#{list[i]} " i += 1 end # Loop 3 (for) for x in list do print "#{x} " end # Loop 4 ('each' iterator) list.each do |x| print "#{x} " end # Loop 5 ('loop' method) i=0 n=list.size-1 loop do print "#{list[i]} " i += 1 break if i > n end # Loop 6 ('loop' method) i=0 n=list.size-1 loop do print "#{list[i]} " i += 1 break unless i <= n end # Loop 7 ('times' iterator) n=list.size n.times do |i| print "#{list[i]} " end # Loop 8 ('upto' iterator) n=list.size-1 0.upto(n) do |i| print "#{list[i]} " end # Loop 9 (for) n=list.size-1 for i in 0..n do print "#{list[i]} " end # Loop 10 ('each_index') list.each_index do |x| print "#{list[x]} " end 

• Hash

Perl中的散列变量以百分号(%)开头，用大括号来存取。

#!perl my %hash; $hash{key} = 'value'; print $hash{key} 

Ruby则使用中括号来存取。

#!ruby key = 2 hash = {} hash[key]= "value" print hash[key] 

如果需要一次指定大量的散列键值，可以用qw//。

#!perl my %hash = qw/1 one 2 two 3 three/; 

等效于

#!perl $hash{1} = 'one'; $hash{2} = 'two'; $hash{3} = 'three'; 

#!ruby hash = {1, "one", 2, "two", 3, "three"} 

如果键值数目不一致，Perl会把最后一个键对应的值赋为undef。

由于容易引起混乱，所以推荐用另一种等价的赋值方式：

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); 

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } print hash[2] 

• each

如果希望一次取出所有的键值对，可以借用each函数。

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); while (my ($key, $value) = each (%hash)) { # 取出雜湊中的每一對鍵值，並且分別放入$key, $value print "$key => $value/n"; } 

each每次送回一个包含一对键值的数组。

• keys和values

有时候只需取出健集：

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); my @keys = keys(%hash); print @keys # 1 3 2 

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } keys = hash.keys print keys # 1 2 3 

或者值集：

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); my @values = values(%hash); print @values # one three two 

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } values = hash.values; print values # one two three 

• exists

判断是否存在某个键值对。

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); print "exists" if (exists $hash{2}); 

Ruby中提供了has_key?来做这事(has_key?有很多别名，include?, key?, member?)

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } print "exists" if hash.has_key? 2 

Ruby还提供了探测是否存在某值的函数has_value?(别名value?)

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } print "exists" if hash.has_value? 'two' 

• delete

删除某个键值对。

#!perl my %hash = ( 1 => 'one', 2 => 'two', 3 => 'three', ); delete $hash{2}; 

#!ruby hash = { 1 => 'one', 2 => 'two', 3 => 'three', } print hash.delete 2 # two 

Ruby还提供了clear, delete, delete_if, reject, reject!, shift等方法来删除键值对。(clear删除所有的键值对，相当于赋一个新的空散列，但是稍微快一点。)

Ruby提供了Perl能为散列提供的一切功能，甚至更多。

• 子程序

Perl在变量名前加&表示该变量是一个子程序。

#!perl &hello; # 印出 hello &hello; # 再印一次 sub hello { print "hello/n"; } 

Perl的子程序可以放在程序的任意位置，而Ruby必须先声明，后调用。

#!ruby def hello print "hello/n" end hello hello 

• 参数

#!perl &hello("world"); # 傳參數"world" sub hello { my $name = shift @_; # 把參數從預設陣列拿出來 print "hello $name/n"; # 根據參數不同印出不同的招呼 } 

当把参数传给子程序时，参数会放在预设的数组@_里（好奇怪的传递方式！）。

#!perl my $return = &adv(4, 2, 6, 4, 9); # 我們一次傳入五個參數 print $return; # 5 sub adv { my $total; for (@_) { # 針對預設陣列進行運算 $total += $_; # 加總 } $total/($#_+1); # 除以總數 (取平均) } 

遇到这种传入参数个数不定的情况，Ruby中可以在形参前加*，表示所有的参数都在该形参所指向的数组内。

#!ruby def adv(*para) total = 0 para.each do |x| total += x end total/para.length end return_value = adv(4, 2, 6, 4, 9) print return_value # 5 

• 返回值

Perl会把子程序中的最后一个运算的值当成预设的返回值。当然，你也可以显式地使用return。

#!perl my $return = &square(4); print $return; # 16 sub square { my $base = shift; $base**2; } 

这一招Ruby也学来了。

#!ruby def square x x ** 2 end return_value = square(4) print return_value # 16 

• 正则表达式

有人说如果Perl少了散列和正则表达式，就什么都不是了。

在Perl中用比对运算子"=~"来进行比对，用m//来括住样式（//也可换成其他成对出现的符合）。

#!perl print "hi, monger" =~ /monger/ # 1 

Perl在完成比对之后会传回成功与否的数值。

Ruby几乎全部继承了Perl的正则表达式。

#!ruby print /monger/ =~"hi, monger" # 4 

所不同的是，Ruby如果比对成功，返回的是匹配开始处的偏移位置。

不多说了，推荐一篇不错的文章—— 你应该知道的八个正则表达式。

• 文件操作

Perl提供了六个常用的file handle：STDIN，STDOUT，STDERR，DATA，ARGV，ARGOUT

#!perl open FILE, "<foo.txt" while (<FILE>) { print $_; } close FILE; 

完整版：

#!perl use strict; open FILE, "<foo.txt" or die "open failed: $!"; while (<FILE>) { print $_; } close FILE; 

$!是Perl的一个预设变量，存储系统产生的错误信息。

#!ruby f = File.open("f:/error.txt") f.each do |line| print line end f.close 

但我更喜欢这样的方式：

#!ruby File.open("f:/error.txt") do |file| file.each do |line| print line end end # The file is now closed 

不用手动去关闭文件。

• 小结：

Perl在命名上使变量处于不同的名字空间，比如标量变量（数字、字符串）以$开头，数组变量以@开头，散列变量以%开头，子程序名以&开头等等。

（待续，学习中……）

总的来说，Ruby像个OO版的Perl。Ruby的的确确从Perl那学来了不少东西，但把我们拉向Ruby阵营的还因为Ruby自身的特色（至于是什么，我还有梳理梳理^_^）。

参考书目：

Perl 學習手札，引用了里面的很多Perl代码。这本书是簡信昌写的一本Perl入门教材，写得通俗易懂，力荐！