nucleus->G<-

第八章异常，catch和throw

2006-07-13T18:56:00.000+09:00

第八章异常，catch和throw

迄今为止我们已在Pleasantville内开发了代码，这是个没有错误的地方。每个库都可成功调用，用户从不会输入错误数据，资源是丰富和廉价的。当然这并不真实。欢迎回到现实中来。

在现实生活中，会有错误发生。好的程序(和程序员)可预见到错误并优雅地安排对错误的处理。但是这并不总是像说起来这么容易。通常，用于侦测错误的代码并不真的知道它们在做什么。例如，在有些情况下，试图打开一个不存在文件的做法可能是合理的，而这在其它时候可是个致命错误。你的文件处理模块用来做什么？

传统方式是使用返回代码。open方法返回一些特定值来说明它失败了。然后这个值在调用例程层中向外传播，直到有人出于责任而捕获它。

这个方式的问题是管理这么多错误代码可能是件痛苦的事。如果一个函数调用open，然后是read，最后是close，而这每一步都可能返回一个错误代码，这个函数如何能够区别调用返回的这些错误代码。

在很大范围内用异常来解决这个问题。异常让你包装有关的错误信息到一个对象内。然后这个异常对象被自动从调用堆栈向外传播，直到运行时系统找到，明确地声明了它知道如何处理这个异常类型的代码。

Exception 类

包含有关一个异常信息的包是个Exception类或它的子类的对象。Ruby预定义了一个简洁的异常层次，像下一页中表8.1显示的。稍后我们会看到，用这个层次处理异常相当地容易。

当你需要引发一个异常时，你可使用内建的Exception类，或你自己创建的异常类中的一个。如果你自己创建，你可能需要让它成为StandardError或它的子类的一个子类。如果你不这么做，你的异常在缺省情况下不会被捕获。

每个异常都有相关的消息字符串一个堆栈轨迹。如果你定义了自己的异常，你可以添加额外的信息。

处理异常

我们自动点唱机使用一个TCP套接字在互联网上下载歌曲。基本代码很简单(假设filename和socket已经设置完了)。

op_file = File.open(opfile_name, "w")

while data = socket.read(512)

op_file.write(data)

end

如果我们在下载到一半时出现了一个致命的错误，这会怎样?当然，我们不会将一个完整的歌曲存储到歌曲列表中。 “I Did It My *click*.”

让我们添加一些异常处理代码，看看这会有什么帮助。为了对异常进行处理，我们封装引起异常的代码在一个begin/end块中，并且使用一或多个rescue子句来告诉Ruby我们想处理的异常类型。在这个特定的例子中，我们只感兴趣SystemCallError异常(当然也包括它的子类)，所以它会出现在rescue行中。在错误处理块内，我们报告错误，关闭和删除输出文件，然后重新引发这个异常。

op_file = File.open(opfile_name, "w")

begin

# Exceptions raised by this code will

# be caught by the following rescue clause

while data = socket.read(512)

op_file.write(data)

end

rescue SystemCallError

$stderr.print "IO failed: " + $!

op_file.close

File.delete(opfile_name)

raise

end

当一个异常出现时，它有单独的异常处理，Ruby放置相关的异常对象的引用在全局变量$!中(异常指针令人惊异地会镜像我们可能引起错误的任何代码)。在前面例子中，我们使用$!变量来格式化我们的错误消息。

在关闭和删除文件后，我们调用无参数的raise，它重新引发$!内的异常。这是个很有用的技术，它允许你编写这样的代码，过滤异常，传递你没有处理的那些异常到上层。它几乎就像是实现的一个对错误处理的继承层次。

你可在一个begin块内使用多个rescue子句，而每个resuce子句可以指定多个要捕获的异常。在每个rescue子句末端时你可以给出一个Ruby的局部变量来接收匹配的异常。很多人认为在下述位置上使用$!更易于阅读。

begin

eval string

rescue SyntaxError, NameError => boom

print "String doesn't compile: " + boom

rescue StandardError => bang

print "Error running script: " + bang

end

Ruby是如何确定哪个rescue子句被执行的？它将它们处理成类似于使用case语句。对begin块内的每个rescue子句，Ruby将被引发异常与每个参数依次比较。如果被引发的异常匹配一个参数，Ruby执行这个rescue子句体并停止查找。这个匹配使用parameter===$!操作完成。对于大多数异常，这意味着如果rescue子句内的异常名若与当前被抛出的异常的类型相同，或是那个异常的一个子类，则匹配将会成功。(注：这种比较这所以会发生，是因为异常是类，类是种模块。而模块内定义的===方法，在做为操作数的类与被调的祖先相同时返回true。)如果你写了无参数rescue子句，则它的缺省参数是StandardError。

如果没有找到匹配的rescue子句，如果一个异常在begin/end块的外部被引发，Ruby在堆栈内移出调用者并从调用者内查找一个异常处理程序，然后是调用者内调用者，依次类推。

尽管rescue子句的参数通常是Exception类的名字，但实际上它们可以是能返回一个异常类的任意表达式(包括方法调用)。

系统错误

但调用操作系统并返回一个错误代码时系统错误被引发。在POSIX系统上，这些错误有如EAGAIN和EPERM等样的名字。(如果你使用Unix系统，你可以输入manerrno来获得这些错误的列表。)

Ruby接受这些错误并将它们包装一个特定的异常对象内。每个对象都是SystemCallError的子类，每个对象都被定义在Errno模块内。这意味着将可使用类名称如Errno::EAGAIN,Errno::EIO,和Errno::EPERM来寻找异常。如果你想获取操作系统的错误代码，每个Errno异常对象都有个类常量叫(有点乱)Errno，它就包含这个值。

Errno::EAGAIN::Errno => 35

Errno::EPERM::Errno => 1

Errno::EIO::Errno => 5

Errno::EWOULDBLOCK::Errno => 35

注意EWOULDBLOCK和EAGAIN有同样的错误号码。这是用于产生个块的计算机操作系统的一个特征—两个常量映射到同一错误号码。要处理它，Ruby会排列它们以便Errno::EAGAIN和Errno::EWOULDBLOCK在rescue子句中被同等对待。你在一个rescue中请求，你就会处理这两者。通过重新定义SystemCallError#===，以便If you ask to rescue one, you’ll rescue either. It does this by redefining SystemCallError#=== so that if two subclasses of SystemCallError are compared, the comparison is done on their error number and not on their position in the hierarchy.

清理

有时候你需要保证代码块的最后部分也会被处理，而不管是否有异常被引发。例如，你可能在进入块时打开一个文件，并且需要确保在块退出时文件会被关闭。

使用ensure子句会做到这点。ensure出现在最后的rescue子句后面，它所包含的代码块在块中止时，总是会得到执行的。它不考虑块是正常退出，还是引发了异常及处理这个异常，或由一个未捕获异常而引起的中止，ensure块都将被执行。

f = File.open("testfile")

begin

# .. process

rescue

# .. handle error

ensure

f.close unless f.nil?

end

else子句也是一样的构造，尽管它不是很有用。如果出现的话，它在rescue子句的后面和任何ensure子句的前面。else子句体只有在主代码体没引发异常时才会被执行。

f = File.open("testfile")

begin

# .. process

rescue

# .. handle error

else

puts "Congratulationsno errors!"

ensure

f.close unless f.nil?

end

再次恢复执行

有时候你可能要纠正异常的错误。在这些情况下，你可以在一个rescue子句中使用retry语句来重新进入到begin/end块中。明显地，这是个无穷尽的循环，所以使用这个特征要小心。

这个例子的代码会再次审理一个异常，可以查看Minero Aoki的net/smtp.rb库。

@esmtp = true

begin

# First try an extended login. If it fails because the

# server doesn't support it, fall back to a normal login

if @esmtp then

@command.ehlo(helodom)

else

@command.helo(helodom)

end

rescue ProtocolError

if @esmtp then

@esmtp = false

retry

else

raise

end

这个代码首先试图使用EHLO命令来连接一个SMTP服务，这个命令没有得到广泛的支持。如果连接失败，代码设置@esmtp变量为false，并且会试图重新连接。如果第二次又失败了，则引发异常给调用者。

主动引发异常

到现在我们一直是在防御，处理由它人引发的异常。你也可反过来。

你可以在你的代码中使用Kernel.raise方法(同义词是Kernel.fail)来引发异常。

raise

raise "bad mp3 encoding"

raise InterfaceException, "Keyboard failure", caller

第一种形式只是简单地重新引发当前异常(或者不是当前异常的RuntimeError)。这可以被用在需要在异常被传递前中途截住它的异常处理程序中。

第二种形式创建一个新的RuntimeError异常，用指定字符串设定它的消息。然后在调用堆栈引这个异常。

第三种形式的第一个参数创建一个异常，然后用第二个参数设置相关消息和堆栈轨迹给第三个参数。典型地，第一个参数即可以是异常层次内的类名字(注：技术上，这个参数可以是任何对象，该对象通过返回object.kind_of?(Exception)为true的对象来表示异常消息。)，也可以是这些类的一个对象实例的引用。堆栈轨迹通常使用Kernel.caller方法来产生。

这儿是些raise的典型例子。

raise

raise "Missing name" if name.nil?

if i >= names.size

raise IndexError, "#{i} >= size (#{names.size})"

end

raise ArgumentError, "Name too big", caller

在最后例子中，我们从堆栈轨迹中移除了当前例程，它通常在库模块中很有用。我们可使用这个特征。下面代码通过传递调用堆栈的一个子集给新的异常来从堆栈轨迹中移除两例程。

raise ArgumentError, "Name too big", caller[1..1]

给异常添加信息

你可以定义你自己的异常，它持有你需要传递给错误的任何信息。例如，某些类型的网络错误所依赖的环境是短暂的。如果这样一个错误发生，则环境是主要的，你可以在异常中设置个标志来告诉处理者，它是否值得去重新操作。

class RetryException <>

attr :ok_to_retry

def initialize(ok_to_retry)

@ok_to_retry = ok_to_retry

end

一个短暂的错误在代码的某处发生。

def read_data(socket)

data = socket.read(512)

if data.nil?

raise RetryException.new(true), "transient read error"

end

# .. normal processing

end

我们调用上一层堆栈来处理异常。

begin

stuff = read_data(socket)

# .. process stuff

rescue RetryException => detail

retry if detail.ok_to_retry

raise

end

Catch 和 Throw

raise和rescue的异常机制中，当出现错误时，它们会放弃异常。有时候这很好，可让你在通常的处理期间从很深的嵌套结构中跳出来。此处的catch和throw也很方便。

catch (:done) do

while line = gets

throw :done unless fields = line.split(/t/)

songlist.add(Song.new(*fields))

end

songlist.play

end

catch定义带有给定名字(可以Symbol或String)标签的块。块通常会被执行直到它遇见throw。

当Ruby遇到一个throw时，它展开调用堆栈来查找带有匹配符号的catch块。当找到时，Ruby在此点上展开堆栈并中止块。所以前面例子中，如果输入中不包含当前被格式化的行，throw将跳到相应的catch的尾部，不只是中止while循环也跳过歌曲列表的播放。如果在调用throw时使用了可选的第二个参数，则catch的值会被做为返回值。

下面例子如果用户对提示的回答是!时，使用throw来中止与用户的会话。

def prompt_and_get(prompt)

print prompt

res = readline.chomp

throw :quit_requested if res == "!"

res

end

catch :quit_requested do

name = prompt_and_get("Name: ")

age = prompt_and_get("Age: ")

sex = prompt_and_get("Sex: ")

# ..

# process information

end

就像这个例子显示的，throw没有必要出现在catch的静态作用域中。

第七章表达式(4-2)

2006-07-13T18:55:00.000+09:00

第七章表达式(4-2)

Defined?, And, Or, 和 Not

Ruby支持所有标准的布尔操作，另外，还引入了新的操作符defined？

操作符and 和&& 两者的值都为true才会返回true。第一个值为真，才会对第二个操作数求值(有时这也被称为短路求值)。这两个操作符的区别是优先级不同（and低于 &&）

类似的 or 和|| 有一方操作数为true就会返回true。如果第一个为false，它们就会对第二个操作数求值。类似and，这两个操作符只有优先级的不同。

有趣的是，and和or有相同的优先级，而&&的优先级高于||。

not和! 返回操作数的相反的值(如果操作数为true，则这个操作符返回false,如果操作数为false，则返回true)。并且nod和！也只是优先级不同。

所有的这些操作符和优先级的总结在324页表22.4中。

操作符defined?将返回nil，如果参数(可以是任意表达式)没有定义的话。否则，将返回后面参数的描述信息。如果参数是yield，defined?(在代码块与当前上下文环境关联)返回字符串”yield”

defined? 1 => "expression"

defined? dummy => nil

defined? printf => "method"

defined? String => "constant"

defined? $_ => "globalvariable"

defined? Math::PI => "constant"

defined? a = 1 => "assignment"

defined? 42.abs => "method"

除了这些布尔表达式，Ruby对象还支持使用方法 ==, ===, <=>, =~, eql?, 和equal?进行对象之间的比较(见表7.1)。除了<=>之外这些操作符都在Object类中定义，但是经常被子类重载。比如，类Array重定义了==方法，判断两个数组相同的条件事它们元素的个数相同，同一位置的元素也相同。

Table 7.1. 通用比较操作符

操作符	意义
==	测试值是否相等
===	在case语句的when子句中用于每个条目与目标比较
<=>	通用比较操作符。返回 −1, 0, 或 +1, 这依赖于被调小于，等于，大于它的参数。
<, <=, >=, >	小于，小于等于，大于等于和大于的比较操作符。
=~	正则表达式模式匹配
eql?	如果被调和参数两者类型相同并且值相等返回true。1 == 1.0 返回true，但是1.eql?(1.0) 为 false
equal?	如果被调和参数有同样的ObjectID，返回true。

== 和 =~ 两者有否定形式, != and !~. 但是，当你的程序被读入时这些会由Ruby转换。a != b 与 !(a == b)是相等的，而 a !~ b 与 !(a =~ b)也是一样的。这意味着如果你的类覆写了== 或 =~ ，你会自动得到!= 和 !~ 。同时，你也不能离开了==和=~而孤立的定义!=和!~两个方法。

你可以使用Ruby range 作为一个布尔表达式，一个类似 exp1..exp2 的range只有在遇到exp1为true，然后exp2又为true之后，才会返回true。我们将在94页显示这个例子。

先前的Ruby1.8中，你可以用正则表达式来当作一个布尔表达式。现在不赞成这样做。你仍可以使用~操作符(580页描述的)来与一个模式匹配$_。

逻辑表达式的值

在书中，我们这样说”如果两个操作符是true，则求值为true。”。但实际上要比这复杂些。操作符and，or,&&和||实际上返回它们的第一参数，该参数决定条件的true或false。重要的是，这是什么意思？

拿表达式”val1 and val2”来说，如果val1是false或nil，那么我们知道这个表达式不会为true。在这种情况下，val1的值决定了表达式的整个值，所以它是被返回的值。如果val1有其它值，那么整个表达式值则依赖于val2，因此它值是返回值。

nil and true => nil

false and true => false

99 and false => false

99 and nil => nil

99 and "cat" => "cat"

Note that despite all this magic, the overall truth value of the expression is correct.

The same evaluation takes place for or (except an or expression’s value is known early if val1 is not false).

false or nil => nil

nil or false => false

99 or false => 99

A common Ruby idiom makes use of this.

words[key] ||= []

words[key] <<>

The first line is equivalent to words[key] = words[key] || []. If the entry in the hash words for key is unset (nil), the value of || will be the second operand, a new, empty array. Thus, this line of code will assign an array to a hash element that doesn’t already have a value, leaving it untouched otherwise. 有时你也会看到将它们写一行上：

(words[key] ||= []) <<>

If 和 Unless表达式

Ruby中的if语句跟其他语言类似。

if song.artist == "Gillespie" then

handle = "Dizzy"

elsif song.artist == "Parker" then

handle = "Bird"

else

handle = "unknown"

end

如果你的if语句写在多行上，可以省略then关键字。

if song.artist == "Gillespie"

handle = "Dizzy"

elsif song.artist == "Parker"

handle = "Bird"

else

handle = "unknown"

end

但是，如果你的语句都写在一行上，then关键字应该写上来分开布尔表达式和后面的语句。

if song.artist == "Gillespie" then handle = "Dizzy"

elsif song.artist == "Parker" then handle = "Bird"

else handle = "unknown"

end

在1.8中你也可使用冒号：来替换then，使代码更简洁些。

if song.artist == "Gillespie": handle = "Dizzy"

elsif song.artist == "Parker": handle = "Bird"

else handle = "unknown"

end

你可以使用0个或多个elsif子句，和一个可选的else子句。

就像我们前面说道的，if是一个表达式，不是一个语句，它可以返回一个值，你不必使用if表达式的返回值，但是它可能有些用处。

handle = if song.artist == "Gillespie" then

"Dizzy"

elsif song.artist == "Parker" then

"Bird"

else

"unknown"

end

Ruby也未if提供了一个否定的形式，unless：

unless song.duration > 180

cost = 0.25

else

cost = 0.35

end

最后，也为使用C语言的程序员准备了C风格的条件表达式：

cost = song.duration > 180 ? 0.35 : 0.25

这个条件表达式在根据?前面的布尔值为true或false返回冒号前面或后面的值。在这个例子中，如果歌曲的时长大于3分钟，将返回.35，否则返回.25，然后，将这个值赋给cost。

If 和 Unless 修饰句

Ruby也借鉴了Perl的一些特点，语句修饰句使我们可以在普通语句的末尾加上条件语句。

mon, day, year = $1, $2, $3 if date =~ /(dd)(dd)(dd)/

puts "a = #{a}" if debug

print total unless total.zero?

对于if修饰句来说，只有当if后面的条件为true，前面的语句才会执行，unless正好和if相反。

File.foreach("/etc/fstab") do |line|

next if line =~ /^#/ # Skip comments

parse(line) unless line =~ /^$/ # Don't parse empty lines

end

因为if本身也是表达式，所以下面的写法将会使代码变得难懂。

if artist == "John Coltrane"

artist = "'Trane"

end unless use_nicknames == "no"

This path leads to the gates of madness.

第七章表达式(4-1)

2006-07-13T18:54:00.000+09:00

第七章表达式(4-1)

到目前为止我们已经用了一些基本的表达式，毕竟，a＝b＋c是最基本的了，你即使不看本章，也能写出一大堆的Ruby代码来。但是那样做不是什么有趣的事情;-)。

Ruby和其它语言的一个不同之处就是任何东西都能返回一个值：几乎所有的东西都是个表达式。在实际中，这有什么意义呢？

一些明显得作用是可以实现链式语句：

a = b = c = 0 => 0

[ 3, 1, 7, 0 ].sort.reverse => [7, 3, 1, 0]

或许不是很明显，C和JAVA中通常的语句，在Ruby中都是表达式。例如，if和case两者都返回最后的表达式执行后返回的值。

song_type = if song.mp3_type == MP3::Jazz

if song.written <>

Song::TradJazz

else

Song::Jazz

end

else

Song::Other

end

rating = case votes_cast

when 0...10 then Rating::SkipThisOne

when 10...50 then Rating::CouldDoBetter

else Rating::Rave

end

我们会在90页祥细地讨论if和case语句。

操作符表达式

Ruby提供的基本操作符集()让人有些惊讶。完整的操作符列表和优先级在324页表22.4中给出。

在Ruby中，很多操作符实际上是做为方法调用实现的。例如，当你执行a*b+c时，实际上是对a的对象引用执行方法*，传递参数b给它。然后你请求从做为计算结果的对象上再执行+方法，传递参数c给它。这实际上等于写：

(a.*(b)).+(c)

因为万物皆对象，所以你可以重定义实例方法，如果你不喜欢现有基本操作符的工作方式，你总是可以重新定义它。

class Fixnum

alias old_plus +

# Redefine addition of Fixnums. This is a BAD IDEA!

def +(other)

old_plus(other).succ

end

1 + 2 => 4

a = 3

a += 4 => 8

a + a + a => 26

很有用的一个技巧是你自己写的的类可以像内建对象一样参与操作符的操作，比如，我们想从一首歌中间某处开始提取一部分音乐，我们可以用索引操作符"[ ]"来完成对指定音乐的抽取：

class Song

def [](from_time, to_time)

result = Song.new(self.title + " [extract]",self.artist,to_time from_time)

result.set_start_time(from_time)

result

end

这段代码扩展了类Song，增加了[ ]方法，这个方法接收两个参数(开始时间和结束时间)。这个方法返回一个新的Song对象，这个对象是歌曲的一部分。然后，我们就可以这样播放这段音乐：

song[0, 15].play

混合表达式（Miscellaneous Expressions）

除了明显的操作符表达式和方法调用，和不是很显眼的语句表达式（比如if或case），Ruby还支持在表达式中使用更多的东西。

命令展开 （Command Expansion）

如果你用反引号（`）来括起来一个字符串，或者用定界形式的前缀%x{ 和 }括起来，那么这个表达式中的字符串默认得会作为底层的操组系统命令来执行。表达式的值是那个命令的标准输出。换行符将不会从结果中去掉，所以返回结果一般都会包含一个回车符。

`date` => "Thu Aug 26 22:36:31 CDT 2004n"

`ls`.split[34] => "book.out"

%x{echo "Hello there"} => "Hello theren"

你也可以在命令字符串中使用表达式展开和所有通常的转义序列。

for i in 0..3

status = `dbmanager status id=#{i}`

# ...

end

执行的命令的返回状态存放在全局变量$?中。

重定义反引号方法

在命令输出表达式中描述中，我们说，反引号之中的字符串将"默认"被做为一个命令来执行。实际上，这个字符串是传递给了Kernel::` 这个方法（一个反引号）来执行。如果你愿意，可以重写这个方法。

alias old_backquote `

def `(cmd)

result = old_backquote(cmd)

if $? != 0

fail "Command #{cmd} failed: #$?"

end

result

end

print `date`

print `data`

produces:

Thu Aug 26 22:36:31 CDT 2004

prog.rb:10: command not found: data

prog.rb:5:in ``': Command data failed: 32512 (RuntimeError)

from prog.rb:10

赋值

我们前面的例子中都涉及到了赋值这一基本表达式，下面，我们来讨论一些关于赋值语句的东西。

一个赋值语句给在左侧的一个变量或属性(左值lvalue)设定一个在它右侧指定的值(右值)。然后这个值作为赋值表达式的返回值返回。也就是说，我们可以用链式赋值来给一些变量赋值：

a = b = 1 + 2 + 3

a => 6

b => 6

a = (b = 1 + 2) + 3

a => 6

b => 3

File.open(name = gets.chomp)

在Ruby中有两种基本的赋值格式，第一种是将对象引用赋值给变量或常量。这种形式被紧密连接到语言中的。

instrument = "piano"

MIDDLE_A = 440

另一种是在赋值语句左边使用对象的属性或者元素的引用。

song.duration = 234

instrument["ano"] = "ccolo"

这些形式比较特殊，因为它们是通过调用左值的方法来实现的，它意味着你可覆写它们。

我们已经看过如何定义一个可修改的对象属性。只需要简单的在方法后面以等号结尾即可。这个方法把接收的参数作为赋值语句的右值。

class Song

def duration=(new_duration)

@duration = new_duration

end

这些属性设置方法没有必须与内部的实例变量一致，你也不需要为每个属性提供读取方法(反过来也是一样)。

class Amplifier

def volume=(new_volume)

self.left_channel = self.right_channel = new_volume

end

在老Ruby版本中，赋值语句的结果是由属性设置方法返回的值。在1.8中，赋值的值总是参数的值；方法的返回值被丢弃。

class Test

def val=(val)

@val = val

return 99

end

t = Test.new

a = t.val = 2

a => 2

在老版本中，a被赋值语句设置为99，在1.8中被设置为2。

在类中使用存取器方法

84页中的例子中为什么我们必须要写 self.leftChannel 而不能省掉self呢？一般的，可修改属性都有一个隐藏的gotcha。通常，一个类中的方法可以直接调用同类或者父类中的其他方法（也就是说，暗中带有self被调）。但是，对于属性修改方法来说这就不管用了，Ruby将把左面的名字作为一个局部变量，而不是一个对写属性方法的调用。　

class BrokenAmplifier

attr_accessor :left_channel, :right_channel

def volume=(vol)

left_channel = self.right_channel = vol

end

ba = BrokenAmplifier.new

ba.left_channel = ba.right_channel = 99

ba.volume = 5

ba.left_channel => 99

ba.right_channel => 5

我们在leftChannel前面忘了写self.了，所以ruby把这个新值赋给了一个方法volume＝的一个局部变量，而这个对象的属性没有任何变化。这可能会经常产生问题。

并行赋值

在学习了一段时间程序设计之后，我们可能会遇到要求将两个变量的值互换：

int a = 1;

int b = 2;

int temp;

temp = a;

a = b;

b = temp;

在Ruby中很简单，只需要：

a, b = b, a

Ruby可以有效的实现并行赋值，所以被分派的值不会影响到赋值本身。在右边的值在被赋给左面的变量或属性之前按照它们的顺讯进行求值，然后对应的赋给左面的属性或变量。一个例子如下，第二行给a，b，c的值分别是x，x＋＝1，x＋＝1计算之后的值。

x = 0 => 0

a, b, c = x, (x += 1), (x += 1) => [0, 1, 2]

当一个赋值语句有多于一个的左值时，这个赋值表达式返回值是个右值的数组。如果一个赋值语句的左值多余右值，多余的左值被设为nil，反过来如果右值多余左值，那么多余的右值将被忽略。如果左值只有一个，右值有多个，那么这些右值将作为一个数组赋给左值。

你也可以在并行赋值语句中分解和扩展数组。如果最后的左值以星号作为前缀，那么所有对应这个得值和以后的值将会组成一个数组，赋给这个左值（如下面第三行的c）；类似的，如果最后一个右值是一个数组，你可以加一个星号作为前缀，Ruby将会把这个数组拆开按相应的位置赋给左值（如下面第六行的c，而且，如果这个数组是唯一的右值，这个星号是可以省略的，作为右值得数组自动拆开，如第二行所示）。

a = [1, 2, 3, 4]

b, c = a => b == 1, c == 2

b, *c = a => b == 1, c == [2, 3, 4]

b, c = 99, a => b == 99, c == [1, 2, 3, 4]

b, *c = 99, a => b == 99, c == [[1, 2, 3, 4]]

b, c = 99, *a => b == 99, c == 1

b, *c = 99, *a => b == 99, c == [1, 2, 3, 4]

嵌套赋值

并行赋值还有一个值得一提的特性，赋值语句左边还可以包括用括号括起来的变量列表，Ruby中叫做嵌套赋值语句。Ruby首先摘出右值中相应的项进行赋值，然后在进行高层的赋值操作。

b, (c, d), e = 1,2,3,4 => b == 1, c == 2, d == nil, e == 3

b, (c, d), e = [1,2,3,4] => b == 1, c == 2, d == nil, e == 3

b, (c, d), e = 1,[2,3],4 => b == 1, c == 2, d == 3, e == 4

b, (c, d), e = 1,[2,3,4],5 => b == 1, c == 2, d == 3, e == 5

b, (c,*d), e = 1,[2,3,4],5 => b == 1, c == 2, d == [3, 4], e == 5

其它赋值形式

像其它语言一样，ruby也为a=a+2提供了类似a+=2的快捷方式。

第二种方式是第一种的深入，这意味着你已定义的那个操作符在你的类内可做为方法来工作。

class Bowdlerize

def initialize(string)

@value = string.gsub(/[aeiou]/, '*')

end

def +(other)

Bowdlerize.new(self.to_s + other.to_s)

end

def to_s

@value

end

a = Bowdlerize.new("damn ") => d*mn

a += "shame" => d*mn sh*m*

你不会在Ruby中找到C和Java中的增量(++)和减量(--)操作符。使用+=和=形式来代替。

条件执行（Conditional Execution）

Ruby有几种不同的机制来实现代码的条件执行；大多数都感觉很类似，也有一些很灵巧。在深入讨论之前，我们先来花点时间看看布尔表达式。

Boolean 表达式

Ruby中的true定义很简单。任何不是nil和常量false的东西都是true。你会发现系统的实现库中很多这种用法。比如，IO#gets ，用来返回一个文件的下一行，如果到了文件末尾，返回nil，所以，我们才可以这样通过while来循环读取数据：

while line = gets

# process line

end

但是，这里对于C，C++和perl程序员来说有一个误区，数字0和长度为0的字符串都不会被解释成false值，需要注意。

第六章深入方法

2006-07-13T18:52:00.000+09:00

第六章深入方法

一些其它语言有函数，过程，方法等，而Ruby中只有方法：一段表达式代码，返回一个值。

到目前为止，我们在这本书中只是基本的介绍了如何定义，使用方法，现在，我们会继续深入的探讨一些关于方法更深层的东西。

方法定义

如同在前面看到的一样，定义一个方法用关键字def。方法名应该以小写字母开头。[如果你用大写字母开头定义一个方法，你不会立即得到一个错误，但是当你调用这个方法时，Ruby首先认为你访问的是一个常量，所以可能会解析错误]被用来做为查询的方法通常名字后面带有一个问号"?"。例如，String提供了chop和chop!两个方法，第一个方法返回一个修改过的字符串，而第二个方法直接就修改了被调本身。可以用来进行赋值的方法的名字后面带有等号(=)。"?"，"!"和"="只允许做为方法名字的后缀。

现在，我们已经指定了我们新方法的名字，如果需要，我们可以定义一些参数。这些是在圆括号内的简单的一个局部变量列表。(包围方法的参数的圆括号是可选的；我们约定，方法有参数时使用它们，没有参数时省略它们。)

def my_new_method(arg1, arg2, arg3) # 3个参数

# Code for the method would go here

end

def my_other_new_method #无参数

# Code for the method would go here

end

Ruby允许为方法的参数设置默认值：如果调用者没有显示的为这些参数提供值，将使用这些默认值。通过"="，就可以为这些参数设定默认值。

def cool_dude(arg1="Miles", arg2="Coltrane", arg3="Roach")

"#{arg1}, #{arg2}, #{arg3}."

end

cool_dude => "Miles, Coltrane, Roach."

cool_dude("Bart") => "Bart, Coltrane, Roach."

cool_dude("Bart", "Elwood") => "Bart, Elwood, Roach."

cool_dude("Bart", "Elwood", "Linus") => "Bart, Elwood, Linus."

方法体中包含了一般的Ruby表达式，但是你不能在方法里面定义非单态类或者模块。如果你在另一个方法内定义了一个方法，则当外部方法被执行时，内部的方法被定义。方法的返回值是方法体最后表达式被执行后的结果，或者你显示的用一个return语句。

可变长度的参数列表

如果我们想给方法传入一个数目不定的参数，或者把所有参数放到一个参数中进行传递的话，该怎么办呢？我们可以在普通的参数后面加入一个特殊的参数，这个参数以"*"开头，就可以达到这个目的了。

def varargs(arg1, *rest)

"Got #{arg1} and #{rest.join(', ')}"

end

varargs("one") => "Got one and "

varargs("one", "two") => "Got one and two"

varargs "one", "two", "three" => "Got one and two, three"

在这个例子中，第一个参数很普通，直接作为第一个参数变量，而后面以"*"开头的参数，将会包括调用时候后面的所有参数，是一个Array的结构，包括了从第二个开始的所有参数。

方法和块

在46页讨论块和迭代的那章时，我们知道，当一个方法被调用时候，可以接收一个块。通常，你只是简单地在方法内使用yield来调用这个块。

def take_block(p1)

if block_given?

yield(p1)

else

end

take_block("no block") => "no block"

take_block("no block") {|s| s.sub(/no /, '') } => "block"

但是，当方法接受参数中最后一个参数以"&"开始的时候，任何与之关联的块都会转换为Proc对象，并且这个Proc对象将会赋值给这个参数（下例中block指向一个Proc对象）。

class TaxCalculator

def initialize(name, &block)

@name, @block = name, block

end

def get_tax(amount)

"#@name on #{amount} = #{ @block.call(amount) }"

end

tc = TaxCalculator.new("Sales tax") {|amt| amt * 0.075 }

tc.get_tax(100) => "Sales tax on 100 = 7.5"

tc.get_tax(250) => "Sales tax on 250 = 18.75"

调用方法

通常，调用一个方法需要指定一个被调，方法名子，还有一些可选参数或者可选的块。

connection.download_MP3("jitterbug") {|p| show_progress(p) }

在这个例子里，connection是被调，downloadMP3是方法名，"jitterbug"是一个参数，{ |p| showProgress(p) }是传递给这个方法的块。

对于类或者模块方法来说，被调是类或模块名：

File.size("testfile") => 66

Math.sin(Math::PI/4) => 0.707106781186548

如果你省略了被调，那么默认为self是被调，即当前对象：

self.class => Object

self.frozen? => false

frozen? => false

self.id => 967900

id => 967900

这种缺省机制也是Ruby实现private方法的体现，private方法不能用一个被调来直接调用，只能在当前对象中使用。

同样，在前个例子中，我们调用self.class，但我们没有使用一个被调来调用这个方法。这是因为class也是Ruby的一个关键字(它引入类定义)，所以使用的话会产生一个语法错误。

方法名后面是可选的参数，如果不会出现歧义的话，调用方法时参数可以不加括号括起来[Ruby文档有时候也叫做这样的方法是命令（commands）]，然而，除非是特别简单的情况，否则还是加上括号的好，要不可能容易出错。(特别地，当被调用的方法是另一个方法的参数时，你必须使用圆括号。除非它是最后一个参数)我们的规则很简单：如果有任何歧义，使用圆括号。

a = obj.hash # Same as

a = obj.hash() # this.

obj.some_method "Arg1", arg2, arg3 # Same thing as

obj.some_method("Arg1", arg2, arg3) # with parentheses.

方法返回的值

每个被调用的方法返回一个值(尽管没有规定说你必须使用这个值)。方法的值是在方法执行期间被计算的最后语句的值。Ruby有个return语句，它从当前运行的方法中退出。return的值是它的参数。如果不需要，则Ruby习惯上是省略这个参数。

def meth_one

"one"

end

meth_one => "one"

def meth_two(arg)

case

when arg > 0

"positive"

when arg <>

"negative"

else

"zero"

end

meth_two(23) => "positive"

meth_two(0) => "zero"

def meth_three

100.times do |num|

square = num*num

return num, square if square > 1000

end

meth_three => [32, 1024]

就像最后一个case显示的，如果你给出有多个参数的return语句，则方法将在一个数组中返回它们。你可以使用并行赋值来收集这个返回值。

num, square = meth_three

num => 32

square => 1024

在方法调用时展开数组

前面我们已经说过了，在一个方法定义内的参数前面可以加一个星号，这样所有后面的参数都被放到了一个数组中，反过来，Ruby也支持调用的时候指定一个数组代替若干个参数。

在调用方法的时候，你可以展开一个数组，它的每个元素都将作为一个单独的参数使用。使用的时候，需要在这个作为参数的数组(which must follow all the regular arguments)前面加一个星号。

def five(a, b, c, d, e)

"I was passed #{a} #{b} #{c} #{d} #{e}"

end

five(1, 2, 3, 4, 5 ) => "I was passed 1 2 3 4 5"

five(1, 2, 3, *['a', 'b']) => "I was passed 1 2 3 a b"

five(*(10..14).to_a) => "I was passed 10 11 12 13 14"

更加动态的块

我们已经看过了如何把一个方法和一个块联系起来。

list_bones("aardvark") do |bone|

# ...

end

通常，这已经足够好了，我们可以给一个方法提供一个合适的块，而不必再方法中使用很多的if或者while等语句。

但是有些时候，你需要更灵活一些，比如，下面的例子，如果选择times，即输入t，将会打印2，4，6，8等等(代码不检查输入错误)：

print "(t)imes or (p)lus: "

times = gets

print "number: "

number = Integer(gets)

if times =~ /^t/

puts((1..10).collect {|n| n*number }.join(", "))

else

puts((1..10).collect {|n| n+number }.join(", "))

end

produces:

(t)imes or (p)lus: t

number: 2

2, 4, 6, 8, 10, 12, 14, 16, 18, 20

虽然这样可以工作，但是不是很完美，事实上if语句的每个分枝是一样的代码。如果我们能用块来计算这些将会更好。

print "(t)imes or (p)lus: "

times = gets

print "number: "

number = Integer(gets)

if times =~ /^t/

calc = lambda {|n| n*number }

else

calc = lambda {|n| n+number }

end

puts((1..10).collect(&calc).join(", "))

produces:

(t)imes or (p)lus: t

number: 2

2, 4, 6, 8, 10, 12, 14, 16, 18, 20

如果最后一个方法的最后一个参数以"&"开头，Ruby把它视为一个Proc对象，它被从参数列表中移除，并被转换成Proc对象传入与这个方法相关联的块内。

哈希结构作为参数

一些语言支持关键字参数，即不按照参数的个数和位置来调用一个方法，而是以任意次序传递带有值的参数的名字。Ruby1.8没有关键字参数(谎言，本书的前一个版本说过它有，或许是在Ruby2.0中)。在这期间，人们使用哈希表来达到同样的效果。例如，我们可以考虑为我们的SongList添加更强大的名字搜索功能。

class SongList

def create_search(name, params)

# ...

end

list.create_search("short jazz songs",

{

'genre' => "jazz",

'duration_less_than' => 270

})

第一个参数是查找的名称，第二个参数是一个包含搜索参数的Hash字面值。使用hash意味着我们可以模仿关键字：音乐流派是jazz，时长小于4.5分钟。但是这个实现还不是太好，而且大括号中的内容很容易被误认为是与方法关联的块。所以，Ruby提供了一个快捷方式，你可以在方法的参数中指定键=>值的结构，像普通的参数那样。这些键值对会被收集到单个Hash中，并做为一个参数传递给方法。花括号则就不需要了。

list.create_search('short jazz songs',

'genre' => 'jazz',

'duration_less_than' => 270)

最后，Ruby习惯上你或许应使用Symbol而不是字符串，因为Symbol会使你引用某些名字变得更清晰

list.create_search('short jazz songs',

:genre => :jazz,

:duration_less_than => 270)

写作风格良好的Ruby程序典型地有很多方法，每个都相当小，所以当定义和使用Ruby方法时应熟悉有效的操作。

第五章标准类型(3-2)

2006-07-13T18:48:00.000+09:00

第五章标准类型(3-2)

范围

范围无处不在：从一月到十二月，0到9，半熟到完全煮熟，从第50行到第67行等等。如果Ruby想要帮助我们很好的根据现实世界来建模，它似乎自然也支持这些范围。事实上，Ruby支持的更好：它实际上使用范围来实现三种分离特征：序列，条件，和间隔。

范围

用作序列

首先或许对范围更自然的使用方式是表达一个序列。序列有起始点，终结点，和产生序列中下一个值的方式。Ruby中，这些序列使用".."和"..."范围操作符创建。两个点的形式创建一个包含范围，而三点的形式创建排除指定最高值的范围。

1..10

'a'..'z'

my_array = [ 1, 2, 3 ]

0...my_array.length

Ruby不像早期的Perl那样，范围并不在内部表示为列表：次序1..100000被存为包含对两个Fixnum对象的引用的Range对象。如果需要，你可以使用to_a把范围转换成数组。

(1..10).to_a ! [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

('bar'..'bat').to_a ! ["bar", "bas", "bat"]

Ranges implement methods that let you iterate over them and test their contents in a

variety of ways.

Ranges实现的方法可以让你以多种方式对其进行迭代，测试它们的内容。

digits = 0..9

digits.include?(5) ! true

digits.min ! 0

digits.max ! 9

digits.reject {|i| i < style=""> ! [5, 6, 7, 8, 9]

digits.each {|digit| dial(digit) } ! 0..9

到现在我们展示了字符串和数字的范围。但是，就像你对面向对象的语言期望的，Ruby可以基于我们定义的对象来创建范围。唯一的限制是，这个对象必须对能返回序列内下一个对象的succ方法的响应，以及这个对象必须是可使用<=>来比较的。有时候调用太空飞船样的操作符，<=>来比较两个值，依赖于第一个值是否小于，等于，或大于第二个值，来返回-1, 0, 或+1。

这儿是个简单的类，它表示由"#"符号表示的行。我们可能想使用它作为自动点唱机音量控制的基于文本的版本。

class VU

include Comparable

attr :volume

def initialize(volume) # 0..9

@volume = volume

end

def inspect

'#' * @volume

end

# 对范围的支持

def <=>(other)

self.volume <=> other.volume

end

def succ

raise(IndexError, "Volume too big") if @volume >= 9

VU.new(@volume.succ)

end

因为们的VU类实现了succ和<=>，它可以使用范围了。

medium_volume = VU.new(4)..VU.new(7)

medium_volume.to_a ! [####, #####, ######, #######]

medium_volume.include?(VU.new(3)) ! false

我们可以创建一个VU的range来测试一下：

medium = VU.new(4)..VU.new(7)

medium.to_a }} [####, #####, ######, #######]

medium.include?(VU.new(3)) }} false

用做条件

除了表示序列外，范围也被用于做条件表达式。这儿，它们的行为像一种开关—当范围的第一部分条件变成true时，它们开户。当第二部分条件变成true时，它们关闭。比如，下面代码片断印出来自标准输入的行集，每个行集的第一行包含单词start最后一行包含单词end。

while line = gets

puts line if line =~ /start/ .. line =~ /end/

end

在背后，范围持有测试的每个状态轨迹。我们将在94页看到些例子。

在Ruby旧版本中，范围很少被用于if，while等相似的语句中。例如，你可以用下面代码片断重写上面的例子

while gets

print if /start/../end/

end

这不被支持。不幸的是，没有错误提示；每次测试也会成功。

用做间隔

范围的最后一个用处是用做间隔测试：看是否有值落在由范围表示的间隔之内。我们使用===来做，它是case等同操作符。

(1..10) === 5 ! true

(1..10) === 15 ! false

(1..10) === 3.14159 ! true

('a'..'j') === 'c' ! true

('a'..'j') === 'z' ! false

case表达式的例子在92页给出。

正则表达式

回到59页，当我们从一个文件里创建歌曲列表时，我们用了正则表达式去匹配输入文件里的界定符字段。我们声明了表达式 line.split(/s*|s*)来匹配一个由任意空格包围的小竖线。让我们更祥细地阐明正则表达式来看看为什么这个声明是正确的。

正则表达式用来匹配与字符串对应的模式。Ruby提供了对方便简洁的模式匹配和替换的内建支持。这一部分，我们将介绍正则表达式的使用重要特征。这儿有些细节我们不会涉及：你可以参考第309页取得更多信息。

正则表达式是类型Regexp的对象。它们可以显式地用构造函数或使用字符值形式/pattern/ 和%r{pattern}来创建。

a = Regexp.new('^s*[az]') ! /^s*[az]/

b = /^s*[az]/ ! /^s*[az]/

c = %r{^s*[az]} ! /^s*[az]/

一旦你有了正则表达式对象，你可以对一个字符串进行匹配，使用Regexp#match(string) 或者用匹配操作符=~（确定匹配）及 !~（否定匹配）。匹配操作定义用于字符串和Regexp对象。至少匹配操作符的一个操作数必须是个正则表达式。(在Ruby的前一个版本中，两都都可以是字符串，在这种情况，第二个操作数在后台被偷偷转换为正则表达式。)

name = "Fats Waller"

name =~ /a/ ! 1

name =~ /z/ ! nil

/a/ =~ name ! 1

匹配出现时，匹配操作符返回字符位置。它们也有个副作用，设置Ruby加载的变量。$&接受模式匹配成功的那部分字符，$`(键盘1左边那个键）接受模式匹配成功的字符串前面的那一部分字符串，$'接受模式匹配成功的字符串后面的那部分字符串。我们可以用这个来编写一个函数，show_regexp，它阐明了一个特殊的模式匹配例子：

def show_regexp(a, re)

if a =~ re

"#{$`}<<#{$&}>>#{$'}"

else

"no match"

end

show_regexp('very interesting', /t/) ! very in<>eresting

show_regexp('Fats Waller', /a/) ! F<>ts Waller

show_regexp('Fats Waller', /ll/) ! Fats Wa<>er

show_regexp('Fats Waller', /z/) ! no match

这个匹配也设置了Ruby的全局线程变量 $~ 和 $1 到 $9。变量 $~ 是一个MatchData对象（在516页开始部分有描述），它保存了所有关于这个匹配的信息。$1等等持有匹配的部分变量。我们稍后讨论它们。如果有人看见这些像Perl语言的变量名感到害怕，不要着急，这章后面还有好消息。

模式

每个正则表达式都有一个模式，用来和一个字符串做匹配。

在一个模式中，除了., |, (, ), [, {, +, , ^, $, *和 ? 之外的字符都是和它本身匹配。

show_regexp('kangaroo', /angar/) => k<>oo

show_regexp('!@%&_=+',/%&/) => !@<<%&>>_=+

如果你想在这些特殊字符字面值上匹配一个字符，在它前面加一个''。这解释了我们用在分离那个歌曲列表文件时用的一个正则表达式的一部分，/s*|s*/。'|'表示匹配一个'|'，没有那个反斜杠，'|'代表着选择（我们会在后面描述）。

show_regexp('yes | no', /|/) => yes <<|>> no

show_regexp('yes (no)', /(no)/) => yes <<(no)>>

show_regexp('are you sure?', /e?/) => are you sur<>

反斜杠后跟一个数字字符用来引进一个特殊的匹配构造，我们会在后面介绍它。另外，一个正则表达式可以包含#{...}展开式。

Anchors

缺省情况下，一个正则表达式将试图查找字符串中第一个匹配的模式。要在字符串"Mississippi"中匹配 /iss/ ，它会找到那个靠近开始位置的哪个子串"iss"。但是当你想自己指定从头部或者末尾开始匹配时要怎么设置呢？

模式 ^ 和 $ 分别匹配一行字符的开始和结束。它们经常用来指定一个模式匹配的方向：比如，/^option/只与在一行文本开始处出现的单词'option'匹配。字符序列 A 和一个字符串的开始匹配，z 和 Z 和一个字符串的结束匹配。（事实上，Z 和一个以"n"结尾的字符串的结束匹配，这种情况下，它从'n'前面开始匹配）。

show_regexp("this isnthe time", /^the/) => this isn<> time

show_regexp("this isnthe time", /is$/) => this <>nthe time

show_regexp("this isnthe time", /Athis/) => <> isnthe time

show_regexp("this isnthe time", /Athe/) => no match

类似的，模式 b 和 B 分别和单词边界和非单词边界匹配。构成单词的字符有字母，数字和下划线。

show_regexp("this isnthe time", /bis/) => this <>nthe time

show_regexp("this isnthe time", /Bis/) => th<> isnthe time

字符类（character class）

字符类是在方括号之间的一系列字符：[characters]匹配方括号里面的任何单个字符。[aeiou]会匹配一个元音，[,.:;!?]匹配标点符号，等等。那些重要的特殊正则表达式字符（.|()[{+^$*?）在方括号里面会失去匹配作用。但是普通的转义字符仍然起作用，所以，b代表退格键，n是换行符（见306页表22.2）。另外，你可以用下页的表5.1的缩写，所以 (例如)s 表示空白符，不仅仅是一个字面上的空格。 The POSIX character classes in the second half of the table correspond to the ctype(3) macros of the same names.

show_regexp('Price $12.', /[aeiou]/) => Pr<>ce $12.

show_regexp('Price $12.', /[s]/) => Price<< >>$12.

show_regexp('Price $12.', /[[:digit:]]/) => Price $<<1>>2.

show_regexp('Price $12.', /[[:space:]]/) => Price<< >>$12.

show_regexp('Price $12.', /[[:punct:]aeiou]/) => Pr<>ce $12.

在方括号里面，序列 c1-c2 表示包括在c1到c2之间的字符。

a = 'see [Design Patternspage 123]'

show_regexp(a, /[AF]/) => see [<>esign Patternspage 123]

show_regexp(a, /[AFaf]/) => s<>e [Design Patternspage 123]

show_regexp(a, /[09]/) => see [Design Patternspage <<1>>23]

show_regexp(a, /[09][09]/) => see [Design Patternspage <<12>>3]

如果你想包含字符类内的方括号 ] 和 - 的话，它们必须出现在开始。在左方括号后直接跟个^来否定一个字符类：[^a-z]匹配任何不是小写的字母。

a = 'see [Design Patternspage 123]'

show_regexp(a, /[]]/) => see [Design Patternspage 123<<]>>

show_regexp(a, /[]/) => see [Design Patterns<<>> page 123]

show_regexp(a, /[^az]/) => see<< >>[Design Patternspage 123]

show_regexp(a, /[^azs]/) => see <<[>>Design Patternspage 123]

有些字符类使用频繁，Ruby为它们提供了缩写。这些缩写列在下一页的表5.1中—它们即可以用在方括号中可以用在模式中。

show_regexp('It costs $12.', /s/) => It<< >>costs $12.

show_regexp('It costs $12.', /d/) => It costs $<<1>>2.

最后，一个句点"."出现在方括号外面表示除了换行符以外的任何字符（尽管在多行模式下它也匹配一个换行符）。

a = 'It costs $12.'

show_regexp(a, /c.s/) => It <>ts $12.

show_regexp(a, /./) => <>t costs $12.

show_regexp(a, /./) => It costs $12<<.>>

Table 5.1. Character class abbreviations

-------------------------------------------------------------------------------

Sequence As [ . . . ] Meaning

------------------------------------------------------------------------------------

d [0-9] Digit character

D [^0-9] Any character except a digit

s [strnf] Whitespace character

S [^strnf] Any character except whitespace

w [A-Za-z0-9_] Word character

W [^A-Za-z0-9_] Any character except a word character

------------------------------------------------------------------------------

POSIX Character Classes

------------------------------------------------------------------------------

[:alnum:] Alphanumeric

[:alpha:] Uppercase or lowercase letter

[:blank:] Blank and tab

[:cntrl:] Control characters (at least 0x00–0x1f, 0x7f)

[:digit:] Digit

[:graph:] Printable character excluding space

[:lower:] Lowercase letter

[:print:] Any printable character (including space)

[:punct:] Printable character excluding space and alphanumeric

[:space:] Whitespace (same as s)

[:upper:] Uppercase letter

[:xdigit:] Hex digi

第五章标准类型(3-1)

2006-07-13T18:46:00.000+09:00

第五章标准类型(3-1)

到现在我们已经实现了我们那点唱机的一部分代码，但是我们还是很粗心的。我们看到了数组，哈希，过程对象Proc，但我们还没有涉及到Ruby中其他的基本数据类型：数字，字符串，范围（ranges），正则表达式。下面我们就要花些时间来看看这些基本构建材料。

数字型

Ruby支持整型和浮点型两种数字类型。整型可以是任意长度（最大值由你机器的内存大小决定）。整型带有一定范围（通常是-230 to 230-1 or -262 to 262-1）在内部由二进制方式表示，整型是类Fixnum的对象。大小超过这个范围的整数由Bignum类的对象存储(当前做为一个可变长度的整数集实现)。如果Fixnum计算之后结果超出范围，自动转换为Bignum。Ruby在两者之间自动转换，对用户来说是透明的。

num = 81

6.times do

puts "#{num.class}: #{num}"

num *= num

end

produces:

Fixnum: 81

Fixnum: 6561

Fixnum: 43046721

Bignum: 1853020188851841

Bignum: 3433683820292512484657849089281

Bignum: 11790184577738583171520872861412518665678211592275841109096961

你也可以使用一个可选的引导符号来写整数，一个可选的基本的指示符(0用于八进制，0d用于十进制[缺省的]，0x用于十六进制)，跟随在适当基数数字字符串后面。数字字符串内的下划线被忽略(一些人使用它们来代替大数字的逗号)。

123456 => 123456 # Fixnum

0d123456 => 123456 # Fixnum

123_456 => 123456 # Fixnum underscore ignored

543 => 543 # Fixnum negative number

0xaabb => 43707 # Fixnum hexadecimal

0377 => 255 # Fixnum octal

0b10_1010 => 42 # Fixnum binary (negated)

123_456_789_123_456_789 => 123456789123456789 # Bignum

控制字符通常可以由?Cx与?cx(x的控制版本是x & 0x9f)生成。Metacharacters (x | 0x80)可以使用?Mx生成。Meta-Control由?MCx生成。你可以使用序列?来获取一个反斜线字符的值。

?a => 97 # ASCII character

?n => 10 # code for a newline (0x0a)

?Ca => 1 # control a = ?A & 0x9f = 0x01

?Ma => 225 # meta sets bit 7

?MCa => 129 # meta and control a

?C? => 127 # delete character

一个带小数点或者带指数的数字字面值会转换成一个Float对象，对应于本机操作系统构架的double数据类型。你必须在小数点后面加一个数字(如果你将1.0e3写成1.e3，Ruby将会试图调用类Fixnum中的方法e3)。

所有数字都是对象，会响应一些消息（在420, 463,466, 480和541页会完整的描述）。所以不像（比如说） C++，你会发现求一个数字的绝对值是这样写的 aNumber.abs，而不是abs(aNumber)。

整数也支持一些有用的迭代器。我们已经看到过一个:6.times在前面的代码例子中。还有其他的比如 upto 和 downto，用来在两个整数之间向上和向下迭代，类Numeric也提供了更通用的方法step，它更像一个传统的 for 循环语句。

3.times { print "X " }

1.upto(5) {|i| print i, " " }

99.downto(95) {|i| print i, " " }

50.step(80, 5) {|i| print i, " " }

produces:

X X X 1 2 3 4 5 99 98 97 96 95 50 55 60 65 70 75 80

最后，给Perl使用者提供一个警告。只含有数字字符的字符串在表达式中使用时不会自动转换成数字。这最有可能在从文件里读取数字时引发错误。例如，我们可能想从文件的每行中找出两个数的和如

3 4

5 6

7 8

下面代码不会工作。

some_file.each do |line|

v1, v2 = line.split # split line on spaces

print v1 + v2, " "

end

produces:

34 56 78

问题就出在程序把输入当成字符串，而不是数字的。加号运算符把两个字符串连接，所以这就是我们看到的输出。要解决这个问题，我们可以使用Integer将字符串转换成整数。

some_file.each do |line|

v1, v2 = line.split

print Integer(v1) + Integer(v2), " "

end

produces:

7 11 15

字符串

Ruby的字符串是简单的8位字节（8-bit bytes）序列。它们通常保存可打印字符序列，但是这不是必需的；一个字符串也可以保存二进制数据。字符串是类String的对象。

字符串通常用字符串字面值建立---两个定界符内字符序列。因为二进制数据很难在程序代码里面表达，你可以在一个字符串字面值中使用各种转义序列。每个转义序列都会在程序编译的时候转换成相应的二进制数值。字符串界定符的种类由完成的置换操作的程序决定。单引号内的字符串，两个连续的反斜线会被一个反斜杠取代，一个反斜杠后面跟一个单引号变成一个单引号。

'escape using ""' ! escape using ""

'That's right' ! That's right

双引号字符串支持更多的转义序列。最常见的可能是"n"，新行字符。第306页的表22.2给出了完整列表。另外，你可以用序列 #{ expr } 来把任何的Ruby代码的值置换到字符串中。如果代码只是个全局变量，类变量或者实例变量，你可以省略花括号。

"Seconds/day: #{24*60*60}" ! Seconds/day: 86400

"#{'Ho! '*3}Merry Christmas!" ! Ho! Ho! Ho! Merry Christmas!

"This is line #$." ! This is line 3

以内插值替换的代码可以是一个或多个语句，不只是一个表达式。

puts "now is #{ def the(a)

'the ' + a

end

the('time')

} for all good coders..."

produces:

now is the time for all good coders...

还有三种方法来构建字符串字面值：%q, %Q和多行字符串的字面值

%q 和 %Q用来界定单引号和双引号字符串(你可以将%q想像为单薄的’，而%Q是厚重的”)。

%q/general singlequoted string/ ! general singlequoted string

%Q!general doublequoted string! ! general doublequoted string

%Q{Seconds/day: #{24*60*60}} ! Seconds/day: 86400

跟在'q'或者'Q'后面的字符是界定符。如果是左侧的方括号，圆括号，小括号或者小于符号(“[”, “{”, “(”, “<”,)，那么程序会一直读直到匹配的右侧被发现为止。否则，一直读取字符串直到下一个同样界定符出现的位置。界定符不可以是任何非字母非数字或多字节字符。

最后，你可以使用一个多行字符串的字面值来构建字符串。

string = <

The body of the string

is the input lines up to

one ending with the same

text that followed the '<<'

END_OF_STRING

多行字符串字面值由包含在开始到一个由你在'<<'后面指定的结束符之间的（但是不包括结束符）多行字符串组成。一般的，这个结束符必须在第一列开始。但是如果你在'<<'后面加一个减号，你就可以缩进结束符了。

print <<

Concat

STRING1

enate

STRING2

produces:

Concat

enate

注意这种情况下Ruby没有去除字符串内容的前导空格。

运用字符串

String可能是最大的Ruby内建类了，它有超过75个标准方法。我们不会在这里挨个介绍它们；函数库参考有它们完整的介绍。相反，让我们先来看看几个常用的字符串用法---在日常编程中我们经常会用到的。

让我们回头看看我们的点唱机。尽管它是被设计成联接到互联网上的，但是也保存了一些很流行的歌曲在本地硬盘上。这样，即使我们的网络连接出问题了，我们仍然能够服务我们的顾客。

由于历史的原因（还有其他原因吗？），歌曲列表是以行的形式保存在一文本文件内。文件中的每行内容包含了歌曲，歌曲长度，演唱者和曲名，所有的字段都是用小竖线分隔开的。一个典型的文件如下：

/jazz/j00132.mp3 | 3:45 | Fats Waller | Ain't Misbehavin'

/jazz/j00319.mp3 | 2:58 | Louis Armstrong | Wonderful World

/bgrass/bg0732.mp3| 4:09 | Strength in Numbers | Texas Red

: : : :

观察一下数据，很明显在我们建立一些基于这个文件的Song对象之前，我们需要用String类的一些方法来展开和清理这些字段。至少，我们需要：

l 将行分解成字段，

l 将时间从MM:SS格式转换成秒，然后

l 移除演唱者名字中额外空格。

我们的第一个任务是要把每行分解成字段， String#split 方法是最适合的了。在这里，我们传递给split方法一个正则表达式，/s*|s*/，split会用找到有任意空格的竖线将行分解成记号，还有，因为从文件里读取的行后面跟了一个换行符，在我们用split方法前，我们可以使用String#chomp 来把换行符去掉。

File.open("songdata") do |song_file|

songs = SongList.new

song_file.each do |line|

file, length, name, title = line.chomp.split(/s*|s*/)

songs.append(Song.new(title, name, length))

end

puts songs[1]

end

produces:

Song: Wonderful WorldLouis

Armstrong (2:58)

不幸的是，那个创建原始文件的人在敲入演唱者名字的时候是按列敲的，有些名字里面可能包含额外的空格。这样那些名字在我们极好的，高科技的，24小时运行的显示板上显示会很难看。我们必须去掉那些额外的空格才能继续我们的工作。有很多方法来做这个工作，但是最简单的可能是用String#squeeze ,它会去除重复的字符。我们在这里使用这个方法的 squeeze! 格式，它会改变适当位置的字符串。

File.open("songdata") do |song_file|

songs = SongList.new

song_file.each do |line|

file, length, name, title = line.chomp.split(/s*|s*/)

name.squeeze!(" ")

songs.append(Song.new(title, name, length))

end

puts songs[1]

end

produces:

Song: Wonderful WorldLouis Armstrong (2:58)

最后，还有一个小问题---时间的格式问题：文件说 2:58，我们想要用秒数来表示，178秒。我们可以再次使用 split 函数，把用冒号分隔的两个字段分开。

mins, secs = length.split(/:/)

相反，我们将使用一个相关方法。与split相似的String#scan，它以模式为基础分割字符串。但是，与split不同，用scan允许你指定用来匹配字段的模式。在这个例子中，我们想为分字段和秒字段匹配一个或多个数字。用于一个或多个数字的模式是 /d+/。

File.open("songdata") do |song_file|

songs = SongList.new

song_file.each do |line|

file, length, name, title = line.chomp.split(/s*|s*/)

name.squeeze!(" ")

mins, secs = length.scan(/d+/)

songs.append(Song.new(title, name, mins.to_i*60+secs.to_i))

end

puts songs[1]

end

produces:

Song: Wonderful WorldLouis Armstrong (178)

我们的点唱机有关键字搜索的能力。给一个歌曲名或者演唱者姓名中的单词，它能够列出所有匹配的歌曲。比如，敲进"fats"，它可能列出 Fats Domino, Fats Navarro, 和Fats Waller的歌曲。例如，我们通过建立一个索引类来实现这个功能。给它一个对象和一些字符串，它会索引出那个对象里所有包含在字符串里的单词（有两个或者多个字符的）。这将会阐明String类的更多方法。

class WordIndex

def initialize

@index = {}

end

def add_to_index(obj, *phrases)

phrases.each do |phrase|

phrase.scan(/w[w']+/) do |word| #提取单词

word.downcase!

@index[word] = [] if @index[word].nil?

@index[word].push(obj)

end

def lookup(word)

@index[word.downcase]

end

String#scan 方法能从匹配正则表达式的字符串中抽取元素。在这个例子里面模式“w[-w']+”能匹配任何能出现在单词里的字符，后面跟一个或多个在方括号里指定的东东（一个小横线，另一个单词字符或者一个单引号）。我们会在64页更详细地介绍正则表达式。要让我们的搜索大小写不敏感，我们把我们提取出来的单词和传进来用做查找关键字的单词转化成小写。注意在第一个 downcase! 方法后面的感叹号。就像以前我们使用的 squeeze! 方法一样，"!"是一个标识来表明方法会在适当位置修改被调，在这里表示把字符串变成小写。[这段代码里面有一个Bug, 歌曲"Gone, Gone, Gone"会被索引三次。你能想一个方法修正它吗？]

我们来扩展一下我们的 SongList 类，让它能够在歌曲加进来的时候索引它们，然后加一个用一个字符串查找歌曲的方法。

class SongList

def initialize

@songs = Array.new

@index = WordIndex.new

end

def append(song)

@songs.push(song)

@index.add_to_index(song, song.name, song.artist)

self

end

def lookup(word)

@index.lookup(word)

end

最后，我们来测试一下：

songs = SongList.new

song_file.each do |line|

file, length, name, title = line.chomp.split(/s*|s*/)

name.squeeze!(" ")

mins, secs = length.scan(/d+/)

songs.append(Song.new(title, name, mins.to_i*60+secs.to_i))

end

puts songs.lookup("Fats")

puts songs.lookup("ain't")

puts songs.lookup("RED")

puts songs.lookup("WoRlD")

produces:

Song: Ain't Misbehavin'Fats

Waller (225)

Song: Ain't Misbehavin'Fats

Waller (225)

Song: Texas RedStrength

in Numbers (249)

Song: Wonderful WorldLouis

Armstrong (178)

前面代码中，lookup方法返回匹配的数组。当我们传递数组给puts方法时，它依次简单地印出每个带有新行的元素。

我们可以再花50页的篇幅来介绍 String 类里面的所有方法。但是，现在还是让我们继续来学习一个简单的数据类型：范围。　

第四章容器，块和迭代器(2-2)

2006-07-13T18:44:00.000+09:00

第四章容器，块和迭代器(2-2)

实现迭代器

Ruby迭代器就是一个简单的方法，它能调用代码块。第一眼看上去，Ruby中的块像C，Java，Perl中的块一样，但这只是表面--实际上Ruby的块是分组语句的一种途径，而不是习惯上的那种。

首先，块在源代码中紧挨着方法调用；并且和这个方法的最后一个参数(或者带圆括号的参数)写在同一行上。其次，这个块内的代码不会在解释器遇到时立即被执行，Ruby首先会记住这个块出现的上下文环境（局部变量，当前对象等），然后进入方法。魔术就从这儿开始了。

在方法里面，这个块才会被yield语句调用执行，就像这个块是方法本身一样。无论何时yield在方法中被执行，这个块就会被调用。当这个块执行完退出后，控制立即移交给yield后面的语句（yield来自一个有20多年历史的语言：CLU）。我们来看一个小例子。

def three_times

yield

end

three_times { puts "Hello" }

produces:

Hello

这个块（两个大括号中的代码）被与调用它的方法three_times关联起来。在这个方法里面，yield执行了3次，每次执行它都会调用块内的代码，即打印一个欢迎语句。然而是，什么会使块变得更有趣。是你可以给块传递参数，并且从块中得到结果。下面例子，我们将会得到小于一个指定值得Fibonacci 数列。

def fib_up_to(max)

i1, i2 = 1, 1 # parallel assignment (i1 = 1 and i2 = 1)

while i1 <= max

yield i1

i1, i2 = i2, i1+i2

end

fib_up_to(1000) {|f| print f, " " }

produces:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

在这个例子中，yield语句有个参数。这个参数的值被传递给关联的块。在块的定义内，参数列表出现在两个竖线之间。在这个例子中变量f用来接收传递给yield的值，所以，这个块才能连续打印这个序列的成员。(例子也显示了并列赋值行为，我们会在85页讲到它。)尽管通常都传递一个值给块，但这不是必须的；块可以有任意数量的参数。

如果传递给块的参数是现存的局部变量，这些局部变量将被用做块参数，而且它们的值可由于块的执行而被修改。这对于块内的变量也是一样的。如果它们第一次出现在块内，它们会被本地锁定。不同的是，如果它们第一次出现在块外，这些变量将在两个块之间及它们的环境内被共享。(尽管有时很有用，这个特性还会产生意外行为，这在Ruby团体中产生激烈的争辩。在Ruby2.0中将会修改块继承局部变量的方式。)

做为试验的例子，我们看见块从当前范围内继承了变量a和b，但传递给块的c是本地的(方法defined?返回nil，如果它的参数没有被定义的话)。

a = [1, 2]

b = 'cat'

a.each {|b| c = b * a[1] }

a ! [1, 2]

b ! 2

defined?(c) ! nil

块也可以返回一个值给调用它的方法。这个块中的最后一个表达式的值将会做为yield的值被回传给方法。Array中的find方法就是这样工作的。（find方法实际被定义在模块Enumerable中，它被混合插入到了类Array中。）

class Array

def find

for i in 0...size

value = self[i]

return value if yield(value)

end

return nil

end

[1, 3, 5, 7, 9].find {|v| v*v > 30 } ! 7

这个用法中数组将连续的元素传递给相关联的块。如果这个块返回true，则这个方法返回当前对应的元素。如果没有匹配的元素，方法返回nil。这个方法显示了迭代器的好处。Array类只作自己做拿手的事，访问数组元素，而分离的应用代码只关注它的特殊需求。

一些迭代器对Ruby集合中的很多类型是通用的。我们已经研究了find。另外两个是each和collect。each或许是最简单的迭代器--它们都会对集合的每个元素来调用块。

[ 1, 3, 5,7,9 ].each { |i| puts i }

produces:

Ruby中的each迭代器有特殊地位；第97页我们将讨论它如何被用于基本的for，loop中，在113页我们将看到如何定义each方法，以便为你的类自由地添加更多的功能。

另一个通用的迭代器是collect，它从集合中获取每个元素并将它传递给块。由块处理后返回的结果被构建成一个新的数组。例如：

["H", "A", "L"].collect {|x| x.succ } ! ["I", "B", "M"]

迭代器不仅仅只限于访问现存的数组和哈希表等集合结构上，就像我们在Fibonacci例子中看到的，迭代器能返回被导出的值，这个能力被Ruby用在了input/output类中，它实现了一个迭代器接口，用它来返回I/O流内的连续行(或字节)。(这个例子使用do…end来定义块。这个定义与使用花括号来定义是一样的：do…end的优先级低于{…}。我们在341页讨论这个区别的影响。)

f = File.open("testfile")

f.each do |line|

puts line

end

f.close

produces:

This is line one

This is line two

This is line three

And so on...

让我们来看一个更有用的迭代器。1.8中的inject(名字有些不直观，它定义在模块Enumerable中)方法，它可让你遍历集合中的成员来累积值。例如，你可以为一个数组内的所有元素求和，并使用代码找到它们的结果。(本书第一版中有作者模拟inject的例子。)

[1,3,5,7].inject(0) {|sum, element| sum+element} ! 16

[1,3,5,7].inject(1) {|product, element| product*element} ! 105

inject 这样工作：当被关联的块第一次被调用时，sum被设置为inject的参数（本例为0），element被设为集合内的第一个元素。第二次及以后块被调用时，sum的值被设置为上次调用时由块返回的值。inject的最终值是最后调用时块返回的值。最后的可能是：如果inject被无参数调用，它使用集合的第一个元素做为它初值，并用第二个值开始迭代。这意味着我们可以重写上面的例子

[1,3,5,7].inject {|sum, element| sum+element} ! 16

[1,3,5,7].inject {|product, element| product*element} ! 105

内置的与外置的迭代器

这值得我们再花些时间来比较Ruby与其它语言如C++，Java中的迭代器。在Ruby中，迭代器是内置集合中的—它是个简单的方法，与其它的方法是同样，无论何时调用yield它都产生一个新值。这样使用迭代器就好像是与这个方法相关联的块代码。

在其它语言中，集合不含有它们自己的迭代器，相反，它们生成额外的帮助对象(例如，Java中的Iterator接口)，以携带迭代器状态。从这一方面，及其它很多方面来说，Ruby是一种一目了然的语言。当你写Ruby程序时，你关注于功能的实现，而不是构建脚手架来支持语言本身。

或许应花些时间来看看Ruby的内置迭代器为什么有时不能更好地解决问题。一方面当你需要将迭代器视为一个对象的地方，它的表现就很不好。(例如，传递迭代器到需要访问由那个迭代器返回的每个值的方法内)。另外，在两个并行的集合上使用Ruby的内置迭代器重复也很困难。幸运地，Ruby1.8带来了Generator库(在662页描述)，它提供了Ruby在这种场合下使用的外置迭代器。

用于事务处理中的块

虽然块通常用于迭代器，但它们也有其它用途。让我们看一些。

你可以使用块来定义一大块代码，这些代码必须在一定的事务控制下运行。比如，你经常会打开一个文件，对文件的内容作一些处理，然后当工作完成时，要确保文件在最后会被关闭。尽管我们可以用常规代码实现，可有种观点认为文件应该自己负责关闭它自己。我们可用块来做到。一个简单例子如下（忽略了错误处理等）：

class File

def File.open_and_process(*args)

f = File.open(*args)

yield f

f.close()

end

File.open_and_process("testfile", "r") do |file|

while line = file.gets

puts line

end

produces:

This is line one

This is line two

This is line three

And so on...

open_and_process是一个类方法—它可以不依赖任何特定的File对象而被调用。我们希望它接受与常规的File.open方法一样的参数，但我们不关心这些参数是什么。要做到这些，我们可指定参数为*args，意思是”收集传递给方法的参数到一名为args的数组内”。然后，我们可调用File.open，并传递*args给它做为它的参数。它会展开数组以获取每个参数。

一旦这个文件被打开，open_and_process 将调用yield，然后将打开的文件对象传递给这个块。当块返回后，这个文件将被关闭。这种情况下，关闭文件的任务就从使用文件对象的用户转变为文件本身了。

让文件管理它们自己生命周期的技术是非常有用的，Ruby直接地支持File类有这种功能。如果File.open有关联的块，那么这个块就会用传递过来文件对象作为参数被调用，然后，当块结束后，这个文件会被关闭。这很有趣，也就是说File.open方法有两种不同的行为：当带块调用时，它执行块然后关闭文件。当无块调用时，它返回这个文件的file对象。方法Kernel::block_given?提供了实现这种功能的可能，如果一个块被关联到当前方法，它返回true。使用这个方法，你可以实现与File.open相似的自己的open方法(再一次忽略错误处理)：

class File

def File.my_open(*args)

result = file = File.new(*args)

# If there's a block, pass in the file and close

# the file when it returns

if block_given?

result = yield file

file.close

end

return result

end

前面的例子使用块来控制资源，我们没有地址错误的处理。如果我们想适当地实现这些方法，我们需要确保不论什么原因中止了代码的处理，文件都会被关闭。我们可以使用异常处理来做，我们稍后在101页讨论它。

块可以是闭包

让我们再回来看看自动点唱机。某些时候，我们需要用代码来管理用户界面—人们可以按下按钮选择歌曲并控制自动点唱机。我们需要给这些按钮指定相应的行为：按下START音乐开始。而Ruby中的块就很适合干这样的事情。假设点唱机的设计者通过Ruby扩展为我们提供了一个基本的按钮类。(在261页我们会谈到扩展Ruby。)

start_button = Button.new("Start")

pause_button = Button.new("Pause")

# ...

当用户按下按钮之后会发生什么呢？在Button类内，硬件操纵以便调用方法，button_pressed，将被调用。添加给这些按钮的功能很明显，就是创建Button的子类，然后在每个子类中实现button_pressed 方法。

class StartButton <>

def initialize

super("Start") # 调用Button类的initialize

end

def button_pressed

# do start actions...

end

start_button = StartButton.new

这样做有两个问题，首先，这样将导致产生大量子类。如果接口Button变化了，所有子类都需要维护；第二，按钮按下之后需要执行的行为不应该在按钮上表示，它们不是按钮的特征而是使用这些按钮的点唱机的责任。我们可以用块来消除这二个问题。

songlist = SongList.new

class JukeboxButton <>

def initialize(label, &action)

super(label)

@action = action

end

def button_pressed

@action.call(self)

end

start_button = JukeboxButton.new("Start") { songlist.start }

pause_button = JukeboxButton.new("Pause") { songlist.pause }

上面代码的关键点在JukeboxButton#initialize的第二个参数。如果方法定义的最后一个参数是以&符号做前缀的话，Ruby会在那个方法被调用时查寻代码。如果代码块转向到类Proc的一个对象而且被赋值为参数。那么你可以被这个参数视为任何其它变量。在本例中我们把它赋给实例变量@action 。当回调方法button_pressed 被调用时，我们在那个对象上使用Proc#call方法来调用这个块。

当创建一个Proc对象之后我们得到的是什么呢？很有趣，我们得到的不仅是一串代码，和这个块(一个Proc对象)定义相关联的上下文环境（范围内的）：self值，定义它的方法，变量，常量等。Ruby中的一个有趣的地方就是即使block定义时候的变量已经不在它的使用范围内，这个变量还保留着，仍可以使用。在其它语言中，这个特点被称为闭包。

我们来看一个例子，这个例子使用方法lambda，它把一个块转成一个Proc对象。

def n_times(thing)

return lambda {|n| thing * n }

end

p1 = n_times(23)

p1.call(3) ! 69

p1.call(4) ! 92

p2 = n_times("Hello ")

p2.call(3) ! "Hello Hello Hello "

方法n_times 返回一个Proc对象，这个对象引用了这个函数的参数：thing 。即使这个参数在块被调用时已经不在自己的作用域里了，这个块还是可以访问这个参数。（比如p1.call(4)，这个时候，虽然对p1的赋值语句中的参数23已经超出了作用域范围，但是它仍然保存着23×4＝92。）

无所不在的容器

容器，块，和迭代器是Ruby的核心概念。 The more you write in Ruby, the more you’ll find yourself moving away from conventional looping constructs. Instead, you’ll write classes that support iteration over their contents. And you’ll find that this code is compact, easy to read, and a joy to maintain.

第四章容器，块和迭代器(2-1)

2006-07-13T18:41:00.000+09:00

第四章容器，块和迭代器(2-1)

一个自动点唱机只有一首歌恐怕不会太流行，所以我们需要建立一个歌曲目录和一个等待播放的列表。这都是容器的例子，一个包含若干个对其它对象引用的对象。

目录和播放列表都有类似的操作，增加歌曲，删除歌曲，返回歌曲列表等等。播放列表可能还需要别的方法，比如插入广告，记录累计播放时间等，我们将在后面考虑这些问题。现在，我们需要建立一个通用SongList类，以便在目录和播放列表中使用。

容器

在开始实现之前，我们要知道怎么在SongList对象中存储歌曲列表。我们有三个明显得选择：Ruby的提供的Array，Ruby提供的Hash，或者我们自己创建一个列表结构。下面我们来看看数组合和哈希，然后选择一个来在我们的类中使用。

数组

类Array持有一个对象引用的集合。每个对象引用占据数组的一个位置，用一个正整数索引标识。

你可以使用字面值或者直接地创建一个Array对象。字面值数组是一个简单的在两个方括号之间的对象列表，列表中的每个元素之间用逗号隔开。

a = [ 3.14159, "pie", 99 ] #使用字面值数组。

a.class ! Array

a.length ! 3

a[0] ! 3.14159

a[1] ! "pie"

a[2] ! 99

a[3] ! nil

b = Array.new #直接创建Array对象。

b.class ! Array

b.length ! 0

b[0] = "second"

b[1] = "array"

b ! ["second", "array"]

数组用[ ]操作符指定索引的下标，就像Ruby内的大多数操作符一样，它实际上也是一个方法(类Array的一个实例方法)，因此它可以在子类中被覆写。就像例子中显示的，数组索引从0开始。用正整数索引的数组，它返回在这个位置上的对象，或者当这个位置上没有任何对象时返回nil。用负整数索引的数组，它的计算从尾部开始。（这时候最右边的索引下标为-1，不是0。想想也是，数学上那有-0存在）。　

a = [ 1, 3, 5, 7, 9 ]

a[1] ! 9

a[2] ! 7

a[99] ! nil

有关索引的配置在下页的图4.1中有更多的细节。

你也可以用一对数字[start, count]来对数组进行索引。这将返回一个新数组，它包含原数组中从start开始的count个对象的引用。

a = [ 1, 3, 5, 7, 9 ]

a[1, 3] ! [3, 5, 7]

a[3, 1] ! [7]

a[3, 2] ! [5, 7]

　最后，你也可使用Range对象或Range字面值来对数组进行索引，它的起止位置由两个或三个小点分隔。两个小点则包含end位置，而三个小点则不包含end位置。

a = [ 1, 3, 5, 7, 9 ]

a[1..3] ! [3, 5, 7]

a[1...3] ! [3, 5]

a[3..3] ! [7]

a[3..1] ! [5, 7, 9]

[ ]操作符有个对应的[ ]=操作符，它可以让你设置数组内的元素。如果使用单整数索引，则这个位置上的元素被赋值符号右边的值替换。而中间没有涉及到的位置为设为nil。如下面例子数组最大下标为4，而对a[6]设置新值，a[5]则被设为nil。

a = [ 1, 3, 5, 7, 9 ] ! [1, 3, 5, 7, 9]

a[1] = ’bat’ ! [1, "bat", 5, 7, 9]

a[3] = ’cat’ ! [1, "bat", "cat", 7, 9]

a[3] = [ 9, 8 ] ! [1, "bat", "cat", [9, 8], 9]

a[6] = 99 ! [1, "bat", "cat", [9, 8], 9, nil, 99]

如果在[ ]=操作符中下标索引为两个数字（一个开始位置，一个长度）或者一个Range字面值，则原始数组内对应的一系列值将被替换为操作符右边的值。如果第二个参数即长度为0，则右边的值将被插入到数组当前位置的前面；而且不会有值被删除。如果操作符的右边它本身就是个数组，则使用它的元素进行替换。如果[ ]=右边的长度和左边下标中指定的长度不一样，则原数组会自动进行调整。

a = [ 1, 3, 5, 7, 9 ] ! [1, 3, 5, 7, 9]

a[2, 2] = ’cat’ ! [1, 3, "cat", 9]

a[2, 0] = ’dog’ ! [1, 3, "dog", "cat", 9]

a[1, 1] = [ 9, 8, 7 ] ! [1, 9, 8, 7, "dog", "cat", 9]

a[0..3] = [] ! ["dog", "cat", 9]

a[5..6] = 99, 98 ! ["dog", "cat", 9, nil, nil, 99, 98]

数组有很多有用的方法，使用这些方法你能用数组实现队列，堆栈，列表等各种数据结构。Array方法的完整介绍在第406页。

哈希表

哈希表 (关联数组，映射或字典)与数组类似，它们都是以索引操作对象引用的集合。但是，你只能用整数索引数组，但你却可以用任何类型的对象来索引哈希表：字符串，正则表达式，等等。当你在哈希表内存储值时，你实际上应提供二个对象–-索引，通常称为key，和一个值value。你可以在随后用同样key的hash值索引来取回这个值。哈希表内的值可以是任何类型的对象。

下面的例子使用了哈希表字面值：在两个花括号之间的key=>value列表。

h = { 'dog' => 'canine', 'cat' => 'feline', 'donkey' => 'asinine' }

h.length ! 3

h['dog'] ! "canine"

h['cow'] = 'bovine'

h[12] = 'dodecine'

h['cat'] = 99

h ! {"cow"=>"bovine", "cat"=>99, 12=>"dodecine",

"donkey"=>"asinine", "dog"=>"canine"}

与数组相比，哈希表有个很大的优势：它们可以使用任何对象作为索引。但是，哈希表也有明显的缺点：它们的元素不能被排序，所以你不能轻易地用hash表来实现堆栈或队列。

在Ruby内你会找到使用哈希表的更通用的数据结构。由类Hash实现的方法清单在第471页中给出。

实现一个SongList 容器

现在，我们要准备实现自动点唱机的SongList。首先我们创建一个SongList内需要的基本方法列表。我们将更多地增加它功能，但现在还不行。

append(song) → list

添加给定歌曲到列表内。

delete_first() →song

从列表的前面移除第一首歌，并返回它。

delete_last() → song

从列表的尾部移除一首歌，并返回它。

[index] → song

返回由整数索引指定歌。

with_title(title) →song

返回与给定标题相应的歌曲

上面清单给了我们如何实现的提示。能添加歌曲到尾部，能从前后两端移除，这暗示我们可以使用一个双向队列，当然，我们知道可以使用数组来实现它。同样地，可以从数组支持的列表中以整数位置值返回一首歌。

但是，也需要能通过歌名来取出一首歌，这暗示我们应该使用哈希表，用标题作key用歌曲做value。可是我们应该使用哈希表吗？当然，但这有些问题。首先，哈希表不能排序，所以我们大楖需要使用一个辅助的数组来保持列表的次序。其次，最大的问题是哈希表不支持带有同样value的多个key。对于我们的播放列表也是个问题，同一首歌可能被排在队列中多次。所以，我们现在将使用一个歌曲数组，当需要时用歌名查找它。如果这成为性能的瓶颈的话，我们总是可增加一些以哈希表为基础的查找。

现在我们用基本的initialize方法开始我们的类，它创建我们用于存储歌曲的数组并在实例变量@songs存储对它的引用。

class SongList

def initialize

@songs = Array.new

end

SongList#append方法添加给定的歌曲到@songs数组的尾部。它也返回self，是一个对当前SongList对象的引用。这个习惯很有用，它可以让我们链接多个对append的调用。我们看看这个例子的最后版本。

class SongList

def append(song)

@songs.push(song)

self #返回当有对象。

end

然后，我们将增加delete_first和delete_last方法，通常使用Array#shift和Array#pop方法来实现。

class SongList

def delete_first

@songs.shift

end

def delete_last

@songs.pop

end

到现在一切正常。我们的下一个方法是[ ]，它通过索引访问元素。这些简单的委托方法频繁地出现在Ruby代码中：如果你的代码只包含有一，两行代码的方法，你可以更好的设计它，而不要麻烦使用委托方法。

class SongList

def [](index)

@songs[index]

end

现在，需要快速测试。要这么做，我们需要使用一个测试框架，叫TestUnit，Ruby中自带它。现在我不想完整地描述它(143页的单元测试会祥细地描述它)。现在，我们只需要assert_equal方法，它检查两个参数是否相等，如果不相等它会给出信息。同样，assert_nil方法在它的以数为nil时给出信息。我们使用这些断言来检查从列表中删除正确的歌曲。

测试包括一些初始管理，必须通知Ruby使用TestUnit框架，及告诉这个框架我们写了一些测试代码。然后，我们创建一个SongList和四个song对象，并添加song对象到列表中。(我们使用append返回的SongList对象来将这些方法的调用链接起来。)然后，我们可测试[ ]方法，检查它对一组索引能否返回正确的歌曲(或nil)。最后，我们从列表的start及end值中删除歌曲，并检查这些歌曲是否被返回。

require 'test/unit'

class TestSongList <>

def test_delete

list = SongList.new

s1 = Song.new('title1', 'artist1', 1)

s2 = Song.new('title2', 'artist2', 2)

s3 = Song.new('title3', 'artist3', 3)

s4 = Song.new('title4', 'artist4', 4)

list.append(s1).append(s2).append(s3).append(s4)

assert_equal(s1, list[0])

assert_equal(s3, list[2])

assert_nil(list[9])

assert_equal(s1, list.delete_first)

assert_equal(s2, list.delete_first)

assert_equal(s4, list.delete_last)

assert_equal(s3, list.delete_last)

assert_nil(list.delete_last)

end

produces:

Loaded suite Started

Finished in 0.002314 seconds.

1 tests, 8 assertions, 0 failures, 0 errors

运行测试确定，一个测试内的八个断言全部通过。我们的自动点唱机可以正常工作了。

现在，我们需要添加一些功能，以使它可以通过标题查找歌曲。这包括对列表内歌曲进行扫描，以检查每个标题的歌曲。要做到这些，我们首先需要花费一些时间来讨论Ruby的嵌套特征：迭代器。

块和迭代器

我们的下一个问题是，SongList要实现with_title方法来获取字符串并用标题来搜索歌曲。实现起来似乎很容易：我们已有一个歌曲数组，所以每次都遍历它的每个元素，来查找一个匹配。

class SongList

def with_title(title)

for i in 0...@songs.length

return @songs[i] if title == @songs[i].name

end

return nil

end

这样已经可以工作了，但看起来不是很爽：用一个for循环在数组上进行迭代。有没有更自然的写法呢？

以这种方式，我们的for循环与数组太亲密了；它请求了一个length，然后它依次取回找到的匹配值。为什么不请求数组来对它的每个成员进行测试呢？在Array中我们可找到这样的方法。

class SongList

def with_title(title)

@songs.find {|song| title == song.name }

end

方法find是一个迭代器—它重复地调用代码块。代码块与迭代器都是Ruby中比较有趣的特点。所以，让们花些时间来看看它们。

第三章类，对象和变量(3-3)

2006-07-13T18:40:00.000+09:00

第三章类，对象和变量(3-3)

访问控制

我们设计一个类的接口的时候，一个重要的问题是，我们应该向外界暴露多少内部实现，外部能访问我们的类有多少限制。如果过多的让外部访问内部的东西，可能增加了耦合，用户越来越依赖我们的类的内部实现，而不是逻辑接口。好消息是在Ruby内改变对象状态有个很容易的方式，就是调用它的方法。控制对方法的访问，你就能控制对对象的访问。一个好的小技巧是从不暴露能让你对象处于无效状态的方法。 Ruby提供了三种保护层次：

l Public methods 任何人都可以调用，没有强制的访问控制。方法默认都是public（initialize除外）。

l Protected methods 可以在本类或者子类中调用。访问控制在家族内。

l Private methods 不能用显示的接收者来调用—接收者总是self。这意味着私有方法仅能在当前对象的上下文环境中被调用；你不可以调用其它对象的私有方法。

"protected"和"private"两者的区别非常微妙，在Ruby中，两者的关系和在其他语言中是不一样的。如果一个方法是protected的，它可以在定义它的实例或者子类的实例来调用。如果一个方法是"private"的，只可以在这个方法所处的对象中被使用，不能直接调用另一个对象的private方法。甚至这个对象就是调用者本身。
Ruby和其他oo语言另一个重要的不同点在于，ruby动态确定访问控制，在程序运行而不是静止时，只有你运行到那一行，才会去判断是否出错。

指定访问控制

你在类内部或模块定义时使用public，protected，与private三个中的一个或多个来指定方法的访问等级。每个控制都有两种使用方式。

如果不带参数使用 public/protected/private，那么这后面的方法默认都是指定的值，比如一行写了private，那么后面的方法默认都是private，除非指定了另外的访问控制符。

class MyClass

def method1 # default is 'public'

#...

end

protected # 后面方法将是 'protected'

def method2 # will be 'protected'

#...

end

private # 后面方法将是 'private'

def method3 # will be 'private'

#...

end

public # subsequent methods will be 'public'

def method4 # and this will be 'public'

#...

end

另一种方法，定义方法的时候不指定访问控制符，而是将相关的方法列在对应的访问控制后面，比如：

class MyClass

def method1

end

# ... and so on

public :method1, :method4

protected :method2

private :method3

end

initialize方法自动声明为private型。

现在来看看一个例子。假如我们有一个记帐系统，每一个借方（debit）对应一个贷方（credit），我们要求都必须遵守这个规则，所以我们把debit和credit的方法设成private，提供了一个外部接口来处理：

class Accounts

def initialize(checking, savings)

@checking = checking

@savings = savings

end

private

def debit(account, amount)

account.balance =

amount

end

def credit(account, amount)

account.balance += amount

end

public

#...

def transfer_to_savings(amount)

debit(@checking, amount)

credit(@savings, amount)

end

#...

end

Protected访问控制被用于当对象需要访问同一类的其它对象的内部状态时。例如，我们可能想允许个别Account对象来比较它们账户，但是可能想隐藏这些账户的余额。

class Account

attr_reader :balance # 属性存取器方法'balance'

protected :balance # and make it protected

def greater_balance_than(other)

return @balance > other.balance

end

因为balance 属性是protected，它只对Account对象内部有效。

变量Variables

现在，我们的麻烦是要创建所有些对象，确保我们不要丢下谁。变量用来跟踪一个对象的状态；每个变量持有一个指向对象的引用。

让我们确认一下这些代码。

person = "Tim"

person.id ! 936870

person.class ! String

person ! "Tim"

第一行，Ruby创建了一个带有值”Tim”的新字符串对象，对这个对象的引用被放置在局部变量person中。快速测试显示，这个变量的确获得了字符串，带有一个objectID,一个类，及一个值。

但变量是对象吗？在Ruby中，答案是否定的。一个变量只是指向一个对象的引用。这些对象可能正在某地，比如堆栈中，变量只是指向了这些对象。
我们再看看稍微负责的例子

person1 = "Tim"

person2 = person1

person1[0] = 'J'

person1 ! "Jim"

person2 ! "Jim"

发生了什么事？我们改变了person1的第一个字符，但是person1与person2两都都从”Time”变成了”Jim”。

这是因为变量只是指向一个对象的引用，而不是对象本身。赋值语句person2 = person1 没有创建新的对象，只是person2拷贝了person1的引用而已。所以person1和person2都指向了同一个对象。我们可以在下页的图3.1中看到这些。

有时候赋值语句只是为对象建立了别名，而潜在的创建了新的变量指向同一个对象。但是这不会在我们的代码中引起问题吗？它能，但并不像你想的那么容易出错。例如，图3.1内的例子，我们可以用String的dup方法，这个方法会创建一个新的字符串对象，并且内容和消息接受者（方法执行者）一样。

person1 = "Tim"

person2 = person1.dup

person1[0] = "J"

person1 ! "Jim"

person2 ! "Tim"

如果你不想别人修改一个对象，也可以冻结（freezing）这个对象（我们在377页谈论冻结对象）。如果你修改一个被冻结的对象，Ruby会抛出一个TypeError异常。

person1 = "Tim"

person2 = person1

person1.freeze # prevent modifications to the object

person2[0] = "J"

produces:

prog.rb:4:in `[]=': can't modify frozen string (TypeError)

from prog.rb:4

对Ruby内的类与对象的总结。这些东西很重要；你在Ruby内操纵的每个东西都是对象。我们用对象做的最多的事情就是创建它们集合。但这是我们下章的主题。

nucleus->G<-

第八章 异常，catch和throw

第七章 表达式(4-2)

第七章 表达式(4-1)

第六章 深入方法

第五章 标准类型(3-2)

第五章 标准类型(3-1)

第四章 容器，块和迭代器(2-2)

第四章 容器，块和迭代器(2-1)

第三章 类，对象和变量(3-3)

第八章异常，catch和throw

第七章表达式(4-2)

第七章表达式(4-1)

第六章深入方法

第五章标准类型(3-2)

第五章标准类型(3-1)

第四章容器，块和迭代器(2-2)

第四章容器，块和迭代器(2-1)

第三章类，对象和变量(3-3)