一些基础的Ruby语言编程知识打赏

我们开始于一个简单的Ruby程序,我们写一个方法来返回一个字符串,给这个字符串附加一个人名,我们会调用两次这个方法。

def sayGoodnight(name) 
 result = "Goodnight, " + name
 return result
end
# Time for bed...
puts sayGoodnight("John-Boy")
puts sayGoodnight("Mary-Ellen") 

首先,发表一下大致的感观。Ruby语法是干净的,不需要在行尾加上分号,一行一个语句。Ruby注释开始于#号,结束在行尾,代码布局非常适合你,缩排没有什么意义。(译者:译者不太明白这句的意思)

方法是由关键字def来定义的,紧跟着方法的名字(本例中是“sayGoodnight”),方法的参数括在圆括号中。Ruby不使用大括号来划定复合语句和定义的界限,而是简单地用关键词end来结束它们。我们的方法的主体很简单,第一行把字符串“Goodnight, ”和参数name连接,然后把返回值赋值给局部变量result,第二行把result返回给调用者。注意我们不需要声明变量result,当我们赋值给它的时候,它就存在了。

定义了方法后,我们调用了它两次,每次我们都把返回值传递给puts方法,它简单地把参数输出到一个新行。

Goodnight, John-Boy
Goodnight, Mary-Ellen
“puts sayGoodnight("John-Boy")”这行包含了两个方法调用,一个调用sayGoodnight另一个调用puts,为什么这两个方法中有一个它的参数括在圆括号中,而另一个却没有圆括号,这种情况纯粹取决于感觉,下面的行是完全等价的:

puts sayGoodnight "John-Boy"
puts sayGoodnight("John-Boy")
puts(sayGoodnight "John-Boy")
puts(sayGoodnight("John-Boy"))
但是,生活不是那么简单的,优先规则会使哪个参数被哪个方法使用变得复杂,所以我们建议除了极简单的情况,还是使用圆括号为好。

这个例子也展示了Ruby的string对象,有很多种方法来创建字符串对象,不过最通用的莫过于使用字符串的字面值(译者注:literal不好翻,参考其它翻译作品,这里采用字面值的翻译,大概意思就是字符串本身):在单引号或者双引号之间的字符序列。两者之间的不同是Ruby在转换字面值到字符串对象时所处理的数量,单引号的情况下会少。除了一些例外,字符串字面值就是字符串的值。

双引号的情况下,Ruby要做更多的处理,首先,它要寻找替代序列就是反斜杠开头的字符,把它替换成二进制值。最常见的是"\n",它被替换成换行符,一个字符串如果包含换行符,那么"\n"强制换行。

puts "And Goodnight,\nGrandma"
produces:
And Goodnight,
Grandma
第二件事就是Ruby要修改双引号括住的字符串,字符串中的#{表达式}序列要用表达式的值来替换,我们用这个来重写前面的方法。

def sayGoodnight(name)
 result = "Goodnight, #{name}"
 return result
end 

当Ruby构造这个字符串对象时,它找到name的当前值,并在字符串中替换它。#{...}结构中可以放入任意复杂的表达式,一个简洁的写法是,如果表达式是一个简单的全局变量、实例或者类变量,那么就不必写出大括号。

最后,我们可以让这个方法更加简化,一个Ruby方法的返回值默认是最后被求的表达式的值,所以我们可以省略掉return语句。

def sayGoodnight(name)
 "Goodnight, #{name}"
end 

我们知道这一节很简单,我们讨论了至少一个话题:Ruby名称,为了简单,我们在定义的时候使用了一些术语(像类变量),但是,现在我们要谈到规则,赶在你打游戏之前让我们看看实例变量和类似的一些东西。

Ruby使用一个约定来帮助它区别一个名字的用法:名字前面的第一个字符表明这个名字的用法,局部变量、方法参数和方法名称应该用一个小写字母开头或者一个下划线;全局变量用美元符作为前缀($),而实例变量用@开头,类变量用两个@开头;最后,类名、模块名和常量应该大写字母开头。

词首字母后面可以是字母、数字和下划线的任意组合(规则规定,@后面不可以直接跟数字)。

Example variable and class names
Variables                                         Constants and 
Local         Global     Instance     Class       Class Names  
name          $debug     @name        @@total     PI  
fishAndChips  $CUSTOMER  @point_1     @@symtab    FeetPerMile  
x_axis        $_         @X           @@N         String  
thx1138       $plan9     @_           @@x_pos     MyClass  
_26           $Global    @plan9       @@SINGLE    Jazz_Song  

数组和哈希

Ruby的数组和哈希是有序集合。两者都保存对象的集合,都可以通过键来访问元素。数组的键是一个整数,而哈希支持任何对象作键。数组和哈希都可以生长以便容纳新的元素,对访问元素来说,数组的效率高,但哈希却更灵活。数组和哈希都可以容纳不同类型的对象,你可以使用数组来包含一个整数、一个字符串和一个浮点数,就像你马上看到的那样。

你可以使用数组的字面值来创建和初始化一个数组----一个方括号括起来的元素集合。有了数组对象,就可以访问单个的数组元素,在方括号中写上一个序号就可以,下面的例子就是这样。

a = [ 1, 'cat', 3.14 ]   # 三个元素的数组  

# 访问第一个元素
a[0]         >>   1  
# 设置第三个元素的值
a[2] = nil  
# 输出数组的值 
a            >>   [1, "cat", nil] 

你可以创建一个空数组,用一个没有元素的数组的字面值,或者用数组对象的构造器,Array.new。

empty1 = []
empty2 = Array.new
有时创建一个字符串的数组会变成一种痛苦,充满了引号和逗号,幸运的是,有一个快捷方式%w帮我们完成。

a = %w{ ant bee cat dog elk }  
a[0]         >>      "ant"  
a[3]         >>      "dog"   

Ruby的哈希和数组相似,一个哈希的字面值使用大括号而不是方括号,字面值至少要为每一个条目提供两个对象:一个是键,一个是值。

举例来说,你可能希望把管弦乐团的乐器归类,使用哈希的话就是:

instSection = {
 'cello'     => 'string',
 'clarinet'  => 'woodwind',
 'drum'      => 'percussion',
 'oboe'      => 'woodwind',
 'trumpet'   => 'brass',
 'violin'    => 'string'
} 

这里译为

instSection = {
 '大提琴'     => '弦乐器',
 '单簧管'     => '木管乐器',
 '鼓'         => '打击乐器',
 '双簧管'     => '木管乐器',
 '小号'       => '铜管乐器',
 '小提琴'     => '弦乐器'
} 

索引哈希使用和数组一样的方括号。

instSection['oboe'] >> "woodwind"
instSection['cello'] >> "string"
instSection['bassoon'] >> nil
最后这个例子显示出,如果使用一个不存在的键来索引哈希,默认返回nil。正常情况下这是很方便的,因为nil用在条件表达式中就是false。有时你希望改变这种默认值,例如,如果你使用哈希来计算每一个键出现的次数,那么比较方便的情况是默认值为0,在你创建一个新的空的哈希时改变默认值是很容易的。

histogram = Hash.new(0)
histogram['key1'] >> 0
histogram['key1'] = histogram['key1'] + 1
histogram['key1'] >> 1

控制结构

Ruby包括所有常见的控制结构,像if语句和while循环,Java、C、Perl程序员会感到这些语句的主体周围缺少了大括号,在Ruby中要表示一段主体的结束,我们使用end关键字。

if count > 10
 puts "Try again"
elsif tries == 3
 puts "You lose"
else
 puts "Enter a number"
end 

同样,while语句也由end来结束。

while weight < 100 and numPallets <= 30
 pallet = nextPallet()
 weight += pallet.weight
 numPallets += 1
end 

如果if语句或者while语句的主体是一个简单的表达式,这时Ruby语句修饰符就是一个很有用的快捷方式。简单地写下这个表达式,后面跟上if或者while和条件语句。下面的例子是一个简单的if语句:

if radiation>3000
  puts "Danger,Will Robinson"
end 

再来一次,这次用语句修饰符来重写。

puts "Danger,Will Robinson" if radiation>3000
同样的,一个while循环如下:

while square < 1000
  square = square*square
end 

变得更简洁,

square = square*square while square < 1000 这些语句修饰符看起来和Perl程序员使用的很相似。 正则表达式 Ruby的大多数内置类型对所有的程序员来说都很熟悉,大部分语言都有字符串、整数、浮点数等等类型。但是,直到Ruby产生的时候,正则表达式还只被所谓的脚本语言支持,像Perl,Python,awk等,这应该让人惭愧:正则表达式虽然晦涩难懂,但确实是处理文本的绝佳工具。 要写正则表达式的话能写整整一本书(像《Mastering Regular Expressions》),所以我们不会覆盖所有的内容而只是写一个短篇。我们来看一些正则表达式的例子,你要找到完整的资料看56页的正则表达式。 一个正则表达式就是在一个字符串中用来匹配的特定的模式字符。在Ruby中,用两个斜线括住的模式来显式地创建一个正则表达式(/pattern/),而且,由于Ruby之所以为Ruby的原因,正则表达式当然的也是对象,并且能被处理。 举例,你要写一个模式来匹配一个包含"Perl"或者"Python"的字符串,就用下面的正则表达式: /Perl|Python/ 斜线界定了模式,它包括我们要匹配的两个字符串,用管道符("|")分隔开,你可以在模式中使用圆括号,就像在算术表达中那样,你可以把模式写成这样: /P(erl|ython)/ 也可以在模式中重复声明,/ab+c/匹配一个字符串,它包含一个"a",然后是一个或者多个"b",然后是一个"c"。如果把加号改成星号,就是/ab*c/那么创建的正则表达式是匹配一个"a",0或者更多的"b",和一个"c"。 你也可以用一个模式来匹配一组字符,常见的如"\s"匹配空白字符(空格、Tab、换行符等),"\d"匹配所有的数字,"\w"匹配所有的可打印字符,简单的一个字符"."(一个点号)匹配任意字符。 我们把它们放在一起就可以组合成非常有用的正则表达式。

/\d\d:\d\d:\d\d/    #  类似12:34:56这样的时间
/Perl.*Python/            #  Perl,0或者更多的字符,然后是Python
/Perl\s+Python/           #  Perl,1个或者更多空格,然后是Python
/Ruby (Perl|Python)/      #  Ruby,1个空格,然后是Perl或者Python 

匹配算符"=~"用在正则表达式匹配一个字符串的时候。当模式在字符串中被匹配到后,=~返回它开始的位置,否则返回nil。这意味着你可以在if语句或者while语句中使用正则表达式。例如,下面的代码片断显示当一个字符串中包含"Perl"或者"Python"时的情况。

if line =~ /Perl|Python/
 puts "Scripting language mentioned: #{line}"
end 

字符串中与正则表达式匹配的部分也可以被替换成不同的文本,这要使用Ruby的替代方法。

line.sub(/Perl/, 'Ruby') # 用"Ruby"替换第一个"Perl"
line.gsub(/Python/, 'Ruby') # 用"Ruby"替换所有的"Python"
随着本书的进行,我们还要讨论正则表达式的更多内容。
代码块和迭代器

这一节简短介绍一下Ruby的一个非常特别的功能,我们来认识一下代码块:可以和方法调用关联的一系列代码,就好像这些代码是方法的参数一样,这是一个令人难以置信的强大特性。你可以使用代码块实现回调(但不像Java的匿名内部类那么简单),传递一系列代码(但要比C的函数指针更加复杂),和实现迭代器。

代码块是用大括号或者do...end括起来的一系列代码。

{ puts "Hello" }       # 这是一个代码块
do                           #
 club.enroll(person)        # 这也是代码块
 person.socialize           #
end                          # 

一旦你创建了一个代码块,就可以把它和一个方法调用关联在一起。那个方法能够调用代码块一次或者更多次,用Ruby的yield语句。下面的例子显示了这个过程。我们定义一个方法,这个方法调用yield两次。然后我们调用这个方法,把代码块放在同一行中方法调用的后面(也是方法的所有参数的后面)。[有些人喜欢把和方法关联的代码块当作是一种传递过来的参数。它们虽然是一个级别的,但这没有显示出所有的内涵。最好把代码块和方法当成是协同工作的关系,在它们之间控制在来回交换。]

def callBlock
 yield
 yield
end
callBlock { puts "In the block" } 
结果:
In the block
In the block 

看看代码块中的代码(puts "In the block") 是如何被执行两次的,就是对yield的每一次调用。

你可以在调用yield时给出参数,这些参数传递给代码块。在代码块中,列举变量的名字来接受参数,这些参数被用"|"括着。

 def callBlock
   yield , 
 end
 callBlock { |, | ... } 

代码块贯穿在实现迭代器的Ruby库中,迭代器就是一种方法,用来连续返回某种集合的元素,比如一个数组。

a = %w( ant bee cat dog elk ) # 创建一个数组
a.each { |animal| puts animal } # 迭代所有的内容

produces:
ant
bee
cat
dog
elk
我们来看看实现Array类的each迭代器的可能的方法,我们要用到前面的例子。each迭代器遍历数组的每个元素,每次都调用yield,类似的代码可能会是下面这样:

# 在Array类中...
def each
 for each element
   yield(element)
 end
end 

这样你就可以使用数组的each方法来迭代数组元素提供给代码块,代码块依次在每个元素返回时被调用一次。

[ 'cat', 'dog', 'horse' ].each do |animal|
 print animal, " -- "
end 
结果:
cat -- dog -- horse -- 

类似的,内置在语言比如C或者Java中的许多循环结构在Ruby中就是简单的方法调用,这个方法调用所关联的代码块0次或者更多次。

5.times {  print "*" }
3.upto(6) {|i|  print i }
('a'..'e').each {|char| print char } 
结果: 
*****3456abcde 

在这里,我们让数字5调用一个代码块5次,然后让数字3调用一个代码块,传递给它连续的数值直到6,最后,字符"a"到"e"的区间使用each方法调用一个块。
读写

Ruby带着很完善的I/O库,不过,这本书的大部分例子只介绍了一些很简单的方法,我们已经看到过两个用来输出的方法,puts把它的所有参数写出来,每一个都加入一个新行,print也写出它的参数,不过没有新行。它们两个都能向任意的I/O对象写入,不过默认是写入控制台。

另一个常用的输出方法是printf,它按格式输出参数(就像C或者Perl的printf)。

printf "Number: %5.2f, String: %s", 1.23, "hello"

结果:
Number: 1.23, String: hello
这个例子中,格式字符串"Number: %5.2f, String: %s" 告诉printf用一个浮点数(总共允许5位,小数点后两位)和一个字符串来代替。

有很多种方式来把输入读取到你的程序中,也许,最传统的就是使用gets例程,它从你的程序的标准输入流中返回下一行。

line = gets
print line
gets例程有一个附带效果,它除了返回读取的行,还把它储存到全局变量$_中,这个变量很特殊,在很多环境中它作为默认变量使。如果你调用print而没有带参数,它显示$_的内容;如果你写一个if或者while语句时仅仅使用一个正则表达式作为条件,那么这个表达式匹配的对象是$_。尽管一些纯粹主义者把这看作是令人讨厌的野蛮行径,但是这些简写确实又能帮助我们写出简洁的程序来。例如,下面的程序现实输入流中的所有行中包含"Ruby"单词的行。

while gets           # assigns line to $_
 if /Ruby/          # matches against $_
   print            # prints $_
 end
end 

Ruby方式的写法是使用迭代器:

ARGF.each { |line| print line if line =~ /Ruby/ }
这里使用了预定义对象ARGF,它描述可以被程序读取的输入流。
就是这些,我们已经完成了这个闪电般的Ruby基础特性的旅行,我们简单地看了一下对象、方法、字符串、容器和正则表达式,看了一些简单的控制结构,和迭代器。

以上内容转载自网络,小子觉得对了解ruby有一定用途。



一些基础的Ruby语言编程知识
文章《一些基础的Ruby语言编程知识》二维码
  • 微信打赏
  • 支付宝打赏

无觅相关文章插件,快速提升流量