Wednesday, October 22, 2008

(7)更改控制流程

除了我们上面讲的条件控制语句、循环、迭代器,Ruby还提供了其他的语法来更改程序的控制流程:
  • return:会导致退出一个方法,或者给调用者返回一个值。
  • break:退出一个循环(或者迭代器) 。
  • next:跳过当前循环中的一个迭代,执行下一个迭代。
  • redo:重新开始当前的循环。
  • retry:重新执行当前循环的一个迭代,它还可以用于异常控制语句中。
  • throw/catch:异常控制语句 。
return
return就是退出当前的方法并给调用者返回一个值,如果你熟悉C或者Java语言,你也许已经明白这个关键字是干什么的了,不过,等等,return 在块中的使用还是不太一样的。
return 后面一般会跟一个表达式或者用逗号分隔的多个表达式。如果没有表达式则说明当前方法返回nil。如果有一个表达式,那么方法的返回值就是这个表达式的返回值,如果有多个表达式,那么方法的返回值就是这一系列表达式的返回值。不过Ruby的方法中通常会忽略这个关键字,因为默认情况下方法最后一行的表达式的值就是方法的返回值。使用return 一般有两种情况,要么是你准备在程序中的某个分支就返回方法,要么是你准备返回多个值。
def double(x)
  return nil if x == nil   # 提前返回
  return x, x.dup          # 返回多个值
end
当我们刚开始学习Ruby中的块时,我们通常把它想象成一个内嵌的函数或者一个迷你方法。你可能会认为块的return会返回迭代器yield给他的值,其实不然,return一般用于内嵌方法并直接把内嵌方法的返回值返回给迭代器,如果遇到return这个块就会结束并把最终值返回给迭代器:
def find(array, target)
  array.each_with_index do |element,index|
    return index if (element == target)  # 将找到的值返回给迭代器
  end
  nil  # 如果找不到元素就返回nil
end
break
break在循环中意味着循环的中断,或者说跳出循环,如果你是一个C,Java他们的含义是一样的:
while(line = gets.chop)     # 开始循环
break if line == "quit"   # 跳出循环...
  puts eval(line)
end
puts "Good bye"             # ...循环结束并直接跳转到这里
记住Ruby中的break是可以有值得,你可以在break后跟一个或多个表达式,如果是多个表达式,那么break返回的是一个数组。
next
循环中的next意味着跳过当前的一个迭代:
while(line = gets.chop)     # 开始循环
  next if line[0,1] == "#"  # 如果遇到#就跳过当前迭代执行下一迭代
puts eval(line)
end
如果在块中使用next意味着立即跳出当前的块,并把控制权交给迭代器以便执行下一个迭代:
f.each do |line|              # 开始迭代
  next if line[0,1] == "#"    # 如果遇到#就跳出并执行下一个迭代
  puts eval(line) 
end
同样,next也可以跟返回值,将当前迭代的一个值返回给迭代器:
squareroots = data.collect do |x|
  next 0 if x < 0  # 如果是负数就返回0
  Math.sqrt(x)
end
redo
redo也是中断当前迭代,但是和next不同他不会跳过当前迭代而继续执行,它会使得循环从开始位置执行。
i = 0
while(i < 3)   # 打印结果是"0123" 而不是 "012"
  # 当遇到redo,循环从此处开始执行。
  print i
  i += 1
  redo if i == 3
end
retry 
这个关键字已经在Ruby1.9中弃用。
throw/catch
这两个关键字可以想象为一个多级的break,可以被当作是一种有标记的break。下面是一个例子:
for matrix in data do             # data是一个多层嵌套的数据结构.
  catch :missing_data do          # 标记这个位置,这样我们可以在此处退出.
    for row in matrix do
      for value in row do
        throw :missing_data unless value # 从当前的两个循环退出.
        # 否则执行其他的代码.
      end
    end
  end
  # 这里结束 matrix 迭代.
  # 我们同样在这里结束一个迭代,如果missing_data被抛出.
end

(6)Ruby中的块Blocks

在我们前面介绍迭代器的时候已经用到了块,块类似于方法调用,但是还是有一些区别的,本节将详细介绍块。
块的语法结构
块是不能单独存在的,它必须出现在方法调用之后,也就是说如果块不在一个迭代器或者方法调用中没有yield那么这个块会被忽略。块以{}定义,或者使用do end 关键字,块的一个花括号{ 或者do 关键字必须与迭代器或者方法调用在同一行,否则Ruby解析器无法把它当作迭代器或者方法调用的一部分:
# 打印1到10的数字
1.upto(10) {|x| puts x }   # 块与方法调用位于同一行
1.upto(10) do |x|          # 使用 do/end关键字
  puts x
end
1.upto(10)                 # 没有指定块
{|x| puts x }             # 语法错误:块没有位于方法调用之后
一个通常的做法是,如果块只有一行接单的逻辑则使用{},如果是多行的逻辑,就使用do/end关键字方式。值得一提的是如果你的方法存在参数,那么使用{的时候要给参数加上括号(),如果你的参数没有括号,那么你应该使用do/end方式:
1.upto(3) {|x| puts x }    # 加括号的参数使用{}
1.upto 3 do |x| puts x end # 没有括号参数的方法使用,do/end
1.upto 3 {|x| puts x }     # 语法错误!
块可以有参数,不过它的参数要放在||之间并用逗号分隔,除此之外它和方法参数非常相似:
# 字典对象的each方法有两个参数
hash.each do |key, value|   # 循环调用字典对象的(key,value) 
  puts "#{key}: #{value}"   # 打印key和value
end                         # 块结束
块的返回值
我们在前面提到的块调用中一再说到yield值,但是没有说到返回值,实际上块是有返回值的,返回值就是块的最后一个表达式的值,注意,不要在块中使用return关键字,这个关键字意味着强制结束你的块逻辑执行,有些时候这是不好的,如果你希望块能够返回更多的值你应该使用next关键字:
array.collect do |x|
  next 0 if x == nil  # 如果x==nil返回0
  next x, x*x         # 返回两个值
end
块的变量范围
块内可以有自己的局部变量,这些变量只在块的范围你有效,但是,如果块内的变量名和块外的变量名相同,这时Ruby不会在块内重新声明变量,而是使用块外部的变量。有时候这对我们来说是很有用的,比如:
total = 0   
data.each {|x| total += x }  # 计算数组内所有元素的合计值
puts total                   # 打印合计值
但是有的时候这样不好,比如,如果一个块的参数和一个已经存在的变量重名,那么Ruby不会创建一个新的变量而是使用那个已经存在的变量。比如:
1.upto(10) do |i|         # 十条记录
  1.upto(10) do |i|       # 每条记录有十列
    print "#{i} "         # 打印每一列
end
  print " ==> Row #{i}\n" # 这里试图打印行号,但是实际得到是列号
end
在Ruby1.9中没有这种情况,块中的变量只在当前块中有效,而且不共享块以为定义的变量,如果你打开了-w选项,Ruby会警告你块变量与已经存在的变量重复。Ruby1.9中从语法定义上根本的解决了这个问题,块参数之间使用分号;分隔来表示这是一个块的参数:
x = y = 0            # 局部变量
1.upto(4) do |x;y|   # x和y现在是块的局部变量
                     
  y = x + 1          # 使用块局部变量
puts y*y           # 打印4, 9, 16, 25
end
[x,y]                # => [0,0]:块没有修改外部的局部变量
块可以有多个参数和多个变量下面是一个例子:
hash.each {|key,value; i,j,k| ... }

(5)枚举对象

你可以在Ruby1.8中通过require 'enumerator' 来使用枚举对象,在Ruby1.9中这个对象是内建的,你不用单独导入一个库。枚举对象位于Enumeration::Enumerator,你可以通过new 关键字来创建一个枚举对象,但是通常我们是通过在其它对象上使用to_enum或者enum_for来创建枚举对象。有时候你要为一个方法传递一个数字参数,但是你又担心这个方法可能会改变你的数组,那么通过to_num方法可以创建这个数字的代理对象,你就不必有这样的担心了,因为这时这个对象是不可变的。比如:
process(data.to_enum)  # 而不是使用 process(data)
你还可以给enum_for方法传递参数,比如对象String对象你希望是使用其each_char来获得一个数组:
s = "hello"
s.enum_for(:each_char).map {|c| c.succ }  # => ["i", "f", "m", "m", "p"]

(4)自定义迭代器

定义一个迭代器类似于方法调用,只不过我们这里是调用块中的代码。实现这一功能需要使用yield方法,下面是一个例子,她非常简单实现了调用两次块中代码的功能:
def twice
yield
yield
end

迭代器可以有参数,参数用括号包含并用逗号分隔,当然按照方法定义的规则,括号是可以省略的。下面是一个例子:
# 下面的方法定义了一个迭代器,每次迭代输出一个计算值,输出的结果是m*i+c,要求
# i的值必须在0到n-1之间

def sequence(n, m, c)
i = 0
while(i < n) #循环n次
yield m*i + c # 调用块,并把计算结果传递给块参数
i += 1 # 每次i的值加1
end
end

# 下面是调用的方法,结果将打印 1, 6, 和 11
sequence(3, 5, 1) {|y| puts y }

下面是另一个例子,它传递了两个参数,值得注意的是在这个迭代器中使用了另一个迭代器:
def circle(r,n)
n.times do |i| # 注意这里使用了另一个迭代器
angle = Math::PI * 2 * i / n
yield r*Math.cos(angle), r*Math.sin(angle)
end
end

# 调用这个迭代器将打印:
# (1.00, 0.00) (0.00, 1.00) (-1.00, 0.00) (-0.00, -1.00)
circle(1,4) {|x,y| printf "(%.2f, %.2f) ", x, y }

yield关键字非常类似于方法调用,但是你不能像方法一样给块参数传递另一个块。有时候你定义了一个迭代器,但是如果在调用它的时候没有给出块部分,这回引发一个异常。你可以定义一个缺省行为,在每一个给出块的时候执行你的缺省行为。这需要用到方法block_given?或者iterator?,这两个方法是kernel中定义的方法,所以你可以当作全局函数那样使用:
# 根据公式 m*i+c迭代
# 如果块存在yeild值
def sequence(n, m, c)
i, s = 0, [] # 初始化变量
while(i < n) # 循环n次
y = m*i + c # 计算值
yield y if block_given? # Yield, 如果有块
s << y # 存储值
i += 1
end
s # 返回数组
end

(3)迭代器和枚举对象

尽管我们前面说到的while,until,for循环是Ruby的核心部分,但是通常情况下我们是用的是另一个更特殊的方式,称为迭代器,迭代器是Ruby中非常值得关注的功能,很多介绍Ruby的文章都会出现类似这样的例子:
3.times { puts "thank you!" }  # 打印3次 感谢
data.each {|x| puts x } # 打印data中的每个元素
[1,2,3].map {|x| x*x } # 计算数组的平方
factorial = 1 # 计算n的阶乘
2.upto(n) {|x| factorial *= x }
times,each,map,upto都是迭代器,他们与紧随其后的块进行交互。隐藏在这些复杂操作背后的是yield操作,yield子句会临时从迭代器方法获得一个控制,并把它交给迭代器调用的方法。特别是当控制逻辑贯穿整个代码块的迭代调用,当代模块结束迭代器方法会收回这个控制接着执行yield后的内容。下图是迭代器yield的执行过程:
如你所见,一个代码块是可以有参数的,||中包含的就是参数,就像你在方法定义中()中的参数一样--你可以定义一些列参数,所以yield子句就相当于方法调用。值得注意的是迭代器并不一定全部用于迭代,不如Ruby1.9中定义的tap方法。或者File.open,这个方法是一个迭代器,但是如果其中没有任何参数传入的话,它只代表你打开了一个文件,在open代码块结束的时候文件自动被关闭,这很好的避免了由于忘记关闭程序而带来的问题。
Numeric迭代
Ruby为整数类型定义了3中迭代器,upto方法执行从当前整数对象到传入的整数参数之间的范围内,每一个元素的循环调用。比如
4.upto(6) {|x| print x}   # => 打印"456"

一般来说一个n.upto(m)将执行m-n+1 次循环。downto方法类似于upto不过正好相反,它是从大的数字向小的数字循环。
Integer.times方法执行n次循环,比如:
3.times {|x| print x }    # => 打印"012"

如果你想使用浮点数进行迭代,你可以使用step方法,比如下面的例子中数字从0开始每次增加0.1直到数值达到Math::PI的值,并计算每个迭代只得sin值:
0.step(Math::PI, 0.1) {|x| puts Math.sin(x) }
枚举对象
Array,Range,Hash以及其他的一系列类,定义了一个each方法,这个方法会将集合内的每一个元素传递给代码块。这可能是Ruby中最常用的操作:
[1,2,3].each {|x| print x }   # => 打印"123"
(1..3).each {|x| print x } # => 打印"123" 等同于 1.upto(3)
不仅仅是这些类,Ruby中的IO库定义了each方法,这样你就可以循环的读取文件中的每一行并对其进行处理:
File.open(filename) do |f|       # 打开指定的文件,并将其内容赋值到变量f中
f.each {|line| print line } # 打印f的每一行
end # 结束块并关闭文件
很多类还基于each方法定义了更多专用的方法,比如each_with_index就是其中之一:
File.open(filename) do |f|
f.each_with_index do |line,number|
print "#{number}: #{line}"
end
end
除此之外,枚举对象还定义了一系列其他有用的方法,collect,select,reject和inject。collect方法循环枚举对象中的每个元素然后根据代码块中的计算结果创建一个新的枚举对象
squares = [1,2,3].collect {|x| x*x}   # => [1,4,9]

select 方法用于筛选块中条件判断为true的元素,并返回筛选的结果:
evens = (1..10).select {|x| x%2 == 0} # => [2,4,6,8,10]

reject 方法与select方法正好相反,他筛选块中条件判断为false或nil的元素,并返回筛选的结果:
odds = (1..10).reject {|x| x%2 == 0}  # => [1,3,5,7,9]


inject 方法有点复杂,解释一下,它有两个参数,第一个参数是这个迭代器的计算结果值,第二个参数代表迭代对象的循环时的每一个元素,每次迭代的返回值是第一个参数,在迭代结束的时候返回值就是最终两个参数的迭代计算结果。inject还有一个初始化参数房在括号中,如果这里有一个参数那么它将使枚举对象的第一个元素:
data = [2, 5, 3, 4]
sum = data.inject {|sum, x| sum + x } # => 14 (2+5+3+4)
floatprod = data.inject(1.0) {|p,x| p*x } # => 120.0 (1.0*2*5*3*4)
max = data.inject {|m,x| m>x ? m : x } # => 5 (largest element

Tuesday, October 21, 2008

(2)循环语句

Ruby提供三种简单的循环while,until和for,while循环执行“当”条件表达式为true,until循环执行“直到”条件表达式为true:
x = 10               # 初始化一个循环计数器变量
while x >= 0 do # 如果x大于等于0就之一执行循环
puts x # 打印x的值
x = x - 1 # 递减x的值
end # 循环结束

# 执行这个循环知道x的值大于0就结束循环
x = 0 # 初始化循环计数器
until x > 10 do # 开始循环
puts x
x = x + 1
end # 结束循环
和if语句一样Ruby也提供了一个在一行代码中完成循环的变体:
x = 0                          # 初始化循环计数器
puts x = x + 1 while x < 10 # 执行循环

a = [1,2,3] # 初始化一个数组
puts a.pop until a.empty? # 循环的从数组中移除元素,知道这个数组为空。
这里有一种特殊情况,如果循环执行的代码是一个begin end包含起来的一段代码块,那么代码块的内容会先于循环逻辑判断:
x = 10              # 初始化循环计数器
begin # 在循环表达式判断之前,这段代码会至少执行一次
puts x
x = x - 1
end until x == 0
注意,如果你的代码块不是放在begin end之间,而是放在()中,那么不会在until判断之前执行代码块中的内容:
x = 0               # 初始化
( # 这种方式的代码片段如果条件表达式判断失败不会执行。
puts x
x = x - 1
) until x == 0
最后一个循环是for/in循环,它一般用于数组或者Range,字典对象,用于在这些对象的元素中迭代取值并执行代码,和while until一样,do关键字是可选的,for关键字后跟一个变量,或者用逗号分隔的多个变量,用于代表数组或字典中的元素,所有数组或者字典中的元素全部遍历一遍之后,循环就结束:
# 打印数组中的所有元素
array = [1,2,3,4,5]
for element in array
puts element
end

# 打印字典对象的键/值
hash = {:a=>1, :b=>2, :c=>3}
for key,value in hash
puts "#{key} => #{value}"
end
实际上for /in 循环是基于for语句内容对each方法的实现,比如上面的代码可以写成这样:

hash = {:a=>1, :b=>2, :c=>3}
hash.each do |key,value|
puts "#{key} => #{value}"
end

(1)条件判断语句

这一节要说的是条件控制语句,if, else ,elsif,unless,end。是Ruby中所有的对象都是有值的即使是一个条件判断语句。和大多数语句一样Ruby中条件判断语句用前面提到的关键字实现。比如:
if 条件表达式
要执行的代码
end


如果条件表达式的值为nil和false以外的任何值:if 和end之间的代码都会被执行,条件表达式之后必须换行后再写入要执行的代码,否则的话你需要一个额外的关键字then来分隔出哪部分是条件表达式,哪部分是要执行的代码。
# 如果x小于10 就给它加1
if x < 10 # 通过换行分隔
x += 1
end
if x < 10 then x += 1 end # 通过then关键字分隔

当然,在then关键字之后换行也是允许的:
if x < 10 then
x += 1
end

else关键字用于条件的跳转,如果if的条件不成立那么就执行else 部分的代码。
if data         # 如果data不为空
data << x # 那么在data中增加元素.
else # 否则...
data = [x] # 创建一个新的数组来保存这个元素.
end # 条件判断结束.

elsif关键字相当于else if ,解释一下就是“否则的话,那么如果。。。”
if x == 1
name = "one"
elsif x == 2
name = "two"
elsif x == 3 then name = "three" #elsif后也可以加then关键字
elsif x == 4; name = "four"#可以用分号替带换行
else
name = "many"
end

我们刚才说过Ruby中所有的对象都是有值得包括条件判断语句,条件判断语句返回的值,就是满足条件的代码块最后一行的值:
name = if    x == 1 then "one"
elsif x == 2 then "two"
elsif x == 3 then "three"
elsif x == 4 then "four"
else "many"
end
刚才我们提到,if表达式必须以换行或者then 加end的方式出现,Ruby中还提供了另外一个变体,你可以把要执行的代码放在if前面,条件表达式放在if的后面,then和end都可以不写,不过这种写法要求整个语句只能位于一行中:
puts message if message    # Output message, if it is defined

除了if语句Ruby还提供了一个unless语句,它的结构和if语句相似,但是执行与if语句相反的判断操作,也就是说如果unless后的表达式为false或nil那么就执行其后的代码:
s = unless o.nil?                        # 换行分隔
o.to_s
end
s = unless o.nil? then o.to_s end # then 关键字分隔

不过,unless没有类似elsif这样的语句。
最后在来提提Ruby中的case语句,如果你是Java程序员,你一定用过switch语句,他们的功能是类似的,不过case语句更强的,因为基于case语句的条件表达式可以是任何对象类型。
case
when x == 1
"one"
when x == 2
"two"
when x == 3
"three"
end

你也可以在when 后的条件表达式 后加then关键字来省去换行。或者更简洁的写法(如果你只判断一个变量的值):
name = case x
when 1 # 只比较x的值
"one"
when 2 then "two" # then关键字替代了换行
when 3; "three" # 分号替代了换行
else "many" # else用于提供缺省值
end

case语句中还可以包含多个条件表达式,表示满足其中任何一个条件都可以执行其后的代码:
case
when x == 1, y == 0 then "x is one or y is zero" # 用逗号分隔多个条件
when x == 2 || y == 1 then "x is two or y is one" # ||看起来更容易理解
end
我们前面讲过===在Range中可以判断一个值是否包含在其中,还可以判断一个对象是否是一个类的实例,在case语句中也可以这样使用:
x=1

case
when Numeric===x
print "yes"
else
print "no"
end

Ruby中同样支持?:的简写方式来完成一个条件判断,其中?相当于then,:相当于else:
def how_many_messages(n) # Handle singular/plural 
"You have " + n.to_s + (n==1 ? " message." : " messages.")
end

(5)赋值操作

在Ruby中复制操作通过=实现,这个我们前面一再提到。比如:
x+=1 #等同于x=x+
x*=1 #等同于x=x*1
x,y,z=1,2,3 #Ruby中的平行赋值,x=1,y=2,z=3
x,y,z=[1,2,3] #Ruby中的平行赋值,等号右边可以是一个数组,x=1,y=2,z=3
这些都很好理解,我主要想说说两个特殊情况。局部变量和平行赋值:
对于局部变量,因为没有类似全局变量的符号前缀,所以Ruby无法区分你现在用的x是一个局部变量还是一个方法,在这种情况下,如果你给x赋值那么Ruby认为这是一个局部变量。看下面的代码:
class Ambiguous
  def x; 1; end # 定义一个方法x,返回值为 1

  def test
    puts x      # 没有找到变量名为x,所以调用上面定义的方法:打印 1

    # 因为 "if false" 下面的第一行的赋值不会被执行. 但是
# Ruby解析器已经把他视为一个局部变量了.
    x = 0 if false

    puts x    # 现在x是一个变量但是没有被赋值: 打印nil

    x = 2     # 赋值为2
    puts x    # 所以现在打印 2
  end
end 
 
说到平行赋值,考虑下面的情况,如果等号左边只有一个变量,而右边有多个值,这种情况Ruby会将右边的值转换为一个数组:
x = 1, 2, 3      # x = [1,2,3]
但是如果左边的变量后有一个逗号,结果就不同了:
x, = 1, 2, 3   
  # x = 1;
 其他的值被忽略了
如果等号两边的变量和值不同,结果也不同:
Created with colorer-take5 library. Type 'ruby'

x, y = 1, 2, 3 # x=1; y=2; 3 is not assigned anywhere
#*有特殊的含义,表示后面是一个单独的数组
x, y, z = 1, *[2,3]  # Same as x,y,z = 1,2,3
x,*y = 1, 2, 3  # x=1; y=[2,3]
x,*y = 1, 2     # x=1; y=[2]
x,*y = 1        # x=1; y=[]
#如果存在括号,那么括号内的变量对应等号右边的相应值
x,y,z = 1,[2,3]             #  没有括号:x=1;y=[2,3];z=nil
x,(y,z) = 1,[2,3]           #  加上了括号:x=1;y=2;z=3
a,b,c,d = [1,[2,[3,4]]]     #  没有括号:a=1;b=[2,[3,4]];c=d=nil
a,(b,(c,d)) = [1,[2,[3,4]]] #  加上了括号:a=1;b=2;c=3;d=4
另外需要注意的一点是,如果平行赋值出现在一个方法的后面,Ruby会把逗号分隔的部分当作是方法的参数:
puts x,y=1,2 #Ruby会认为你给puts方法赋值x , y=1 和2 这3个参数。

(4)方法调用

以下四点说明了什么是方法调用:
  1. 方法的调用通过.或者::触发。如果省略了.和::那么说明是在调用自己的方法。
  2. 方法通过方法名调用。
  3. 方法的参数放在一对括号内并用逗号分隔,调用方法是在括号内传递参数,当然括号也不是必须的,你只要顺序给出参数值,并用逗号隔开就可以了。
  4. 另外,一个块(用花括号或者do/end关键字定义的)可以在其中通过yield关键字调用。块和迭代是Ruby提供的强大功能,我们将在后面详细介绍。

puts "hello world"  # "puts" 方法有一个字符串参数
Math.sqrt(2) # "sqrt" Math.sqrt方法有一个参数
message.length # "length" 方法返回message的长度,没有参数
a.each {|x| p x } # "each" 方法在块内部自动执行。
我们看看前面代码中的puts 方法,它是一个全局方法定义在Ruby的kernel中,它可以在任何地方使用。

(3)常量

常量和变量类似,只不过它的值一直保持不变,当然Ruby没有强制规定你不能修改常量的值,只不过如果你修改一个常量的值时会得到一个警告信息。表面上看起来常量和变量没什么区别,不过常量一般以大写字母开头,通常我们会把常量的所有字母都大写LIKE_THIS,并且在每个单词之间用下划线分隔。Ruby中的类目和模块名也是常量,不过它们通常使用每个单词首字母大写的驼峰式写法LikeThis。
常量的特性有些像全局变量,它可以在程序任何地方被引用,但和全局变量不同他可以在类或者模块中定义。
CM_PER_INCH = 2.54  # 定义一个常量.
CM_PER_INCH # 使用这个常量.
如果你在一个类或者模块中定义了一个常量,那么在引用这个常量的时候需要加上类或者模块前缀。
class Master
PP=2.00
end
puts Master::PP

有时候,模块是嵌入到另一个模块中的,这中情况下对常量的引用可以这样写:
Conversions::Area::HECTARES_PER_ACRE

如果一个常量存在于全局范围,那么::前面的内容可以省略:
::ARGV      # 全局常量 ARGV
需要注意的是我们这里说到的“全局”,实际上就是Object类内,也就是说上面的常量实际上是Object::ARGV。
而且如果没有给常量赋值,那么在调用这个常量的时候你会得到NameError异常。


Monday, October 20, 2008

(2)变量

变量就是一个值得名字,创建一个变量的过程就是给这个变量赋值,如果变量出现在等号的左边就是把这个变量的引用赋值给另一个变量。在Ruby中有4中不同类型的变量,以$开头的变量是全局变量,它在整个应用程序中都是有效的;以@和@@开头的变量代表实例变量和类变量;如果变量以下划线_或者消息字母开头,则说明这个变量是一个局部变量。如果在变量中有::说明你要定义一个静态变量比如Math::PI。如果出现点号. 说明你要调用变量所代表的对象的一个方法。Ruby在开始运行的时候还会初始化一系列的全局变量,有关这部分我们后面会讲到。
通常情况下你应该在使用变量前先给变量赋值,或者说初始化这个变量。在某些情况下,你也可以不初始化变量,这在Ruby中是允许的,不过必须遵循一定的规则:
  • 类变量:对于类变量,在使用之前你必须给它赋值,否则你会得到一个NameError的异常。
  • 实例变量:如果你使用了一个未初始化的实例变量,你会得到一个nil值,通常这不是好的编程习惯,如果你打开Ruby的-w选项你会得到一个警告信息。
  • 全局变量:和实例变量一样,如果你使用了未初始化的实例变量,你会得到一个nil值。
  • 局部变量:局部变量比较复杂,因为和其他变量不同,它没有一个明确的符号标记,标明它是一个局部变量还是一个方法调用。如果Ruby解析器识别到一个变量被赋值了,那么它知道这是一个局部变量而不是方法,如果没有赋值操作,Ruby会把它当作是一个方法调用,如果没有这样一个方法,哦,你会得到一个NameError异常。通常,如果一个局部变量没有明确的赋值,Ruby会认为它的值是nil。比如:

a = 0.0 if false    # 这个赋值操作永远不会执行。
print a # 打印nil,即使存在这样一个变量,但是它的值为nil。
print b # NameError: 不存在的变量或者方法。

(1)文字内容与关键字

Ruby中的表达式就是一段代码块,Ruby解析器可以通过它计算并得到一个值。下面是一些例子:
2                  # 一个数字
x # 一个本地变量
Math.sqrt(2) # 一个方法调用
x = Math.sqrt(2) # 赋值操作
x*x # 乘法操作
很多语言在表达式和语句(比如条件控制语句和循环语句)之间作了明确的区分。语句只负责执行程序的流程,它们本身是没有值得,它们用于执行而不是计算。在Ruby中没有这样明确的区分,任何语句,包括类、方法都可以被看作是表达式并且都会返回一个值。
值得注意的是很多表达式属于初级表达式,它们是最简单的表达式类型,它们不可能由其他的表达式组成,比如数字。其它的表达式诸如数组、字典对象等不属于初级表达式。一些Ruby中的初级表达式有其特殊的含义,我们可以把它们成为关键字:
  • nil:代表空对象。
  • true
  • false
  • self:代表对象本身,相当于java中的this
  • __FILE__:是一个字符串,它表示一个Ruby可以操作的文件名,这对于处理异常信息非常有用。
  • __LINE__:结合__FILE__对象使用,它是一个整数,代表文件中的某一行。
  • __ENCODING__:在Ruby1.9中它用于指定编码格式,比如utf-8。


(24)“冻结”和“污染”的对象

出于某些需求你可能不希望你的对象状态被修改,那么在Ruby中你可以通过调用freeze方法实现,如果一个对象被freeze那么任何试图修改对象状态的行为都会抛出异常,这是对象变成了一个不可变对象:
s = "ice"      # 字符串是一个可变对象
s.freeze # 标记这个对象为不可变
s.frozen? # true: 用frozen?方法检查这个对象是否被冻结了
s.upcase! # TypeError: 不能修改一个冻结的对象
s[0] = "ni" # TypeError: 不能修改一个冻结的对象
说到这里我们再来说说对象的复制。Ruby定义了clone和dup方法来复制对象,当你执行这个两个方法的时候你会得到这个对象的拷贝,如果这个对象中存在对另一个对象的内部引用,你只能复制另一个对象的引用而不是它本身。如果你的对象中定义了initialize_copy方法,那么在调用clone和dup方法的时候会触发这个initialize_copy方法来初始化你刚刚复制的对象拷贝。那么这里clone和dup方法对于已经冻结的对象,复制拷贝的结果就不同了,clone得到的是一个冻结的对象,而dup方法得到的是一个“解冻”的对象。
我们的应用程序经常要面对很对安全问题,比如未信任的用户SQL注入操作。Ruby提供了一个方便的方案来处理这一问题。我们可以通过tainted方法来标明一个对象被“污染了”。一旦一个对象被污染了,那么所有派生自他的对象都是被污染的对象,你可以通过tainted?方法检测一个对象是否被污染了:
s = "untrusted"   # 缺省情况下,一个对象是没有被污染的。
s.taint # 把这个对象标记为被污染了
s.tainted? # true: 检查对象是否被污染了
s.upcase.tainted? # true: 被污染对象的派生对象也是被污染的
s[3,4].tainted? # true
通过gets方法读入的用户输入内容:比如命令行参数,环境变量,字符串都自动被标记为感染的。通过clone和dup复制的对象都是“污染的”对象,你可以通过untainted方法标记一个对象没有被污染。
当你设置了全局变量$SAFE时,这种机制非常有用,如果你设置$SAFE为任何非0的值,那么Ruby会限制所有的方法不能使用被污染的对象。

(23)对象的“顺序”

==用于判断对象是否相同,一些类还定义了“顺序”。比如两个对象可能相等,也可能一个对象“小于”另一个对象。数字对象就是一个最好的例子,比如5大于4说明5在4的后面,字符串也存在顺序,字符串的比较通过比较字符串的ASCII码来实现。在Ruby中类的顺序可以通过实现<=>操作符,如果说明操作符左边的值小于右边的,如果返回0说明两边的值是相等的,如果返回1说明,左边的值大于右边的。如果<=>两边的对象是不同的则返回nil。
1 <=> 5     # -1
5 <=> 5 # 0
9 <=> 5 # 1
"1" <=> 5 # nil: 字符串和数字无法比较。

<=> 用于比较已经足够了,但是这个符号看起来不够“直白”。在Ruby的minxin模块中基于<=> 定义了一系列其他的操作符,这样操作符意思更加明确:
  • < 小于
  • > 大于
  • <= 小于等于
  • >= 大于等于
  • > 大于
  • == 等于
如果你所见,这里没有定义!=符号。此外我们还将看到一个方法between?,它用于判断一个对象是否位于两个对象之间:
1.between?(0,10)  # true: 0 <= 1 <= 10
注意如果你个<=>的比较结果是nil,那么所有基于他的比较都返回false,对象Float他的返回结果是NaN.

(22)对象的比较

我们经常要比较两个对象,Ruby中提供了多种比较对象的方法。我们可以通过equal?方法比较两个对象是否相同,通过这种方式是比较两个值是否指向同一个对象的引用。比如:
a = "Ruby"       # 一个字符串对象。
b = c = "Ruby" # 两个字符串对象指向动一个引用。
a.equal?(b) # false: a和b是不同的对象。
b.equal?(c) # true: b和c指向同一个引用。
这种比较方式实际上是比较两个对象的ID是否相同,显然a是一个对象,而b和c指向另一个对象,他们的对象ID是不同的:
a.object_id == b.object_id   # 等同于 a.equal?(b)
还有另一种简单的方式,你可以使用==来比较对象是否相等,他的作用和equal?方法是不一样,它比较的是两个对象的内容是否相同:
a = "Ruby" # 定义一个字符串对象
b = "Ruby"    # 虽然和a的内容相同,但是他们是不同的对象
a.equal?(b) # false: a和b指向不同的对象
a == b # true: 他们的内容是相同的
除了字符串外,数组和字典类也定义了==操作符,如果两个数组或两个字典对象中元素个数相同,且每个元素都相同,那么==返回true.
Numerics对象在比较的时候会做一个简单的最新转换,所以Fixnum类型的1和Float类型的1.0的比较结果是相等。
同样,你可以使用!=来判断两个对象是否不等。
另外,Ruby还提供了eql?方法,它与equal?的功能相同,是一种更精炼的写法。
再来说说有三个等号的比较操作===。通常情况下这中方式与==是一样的,但是在某些特定情况下,===有特殊的含义:在Range中===用于判断等号右边的对象是否包含于等号左边的Range;正则表达式中用于判断一个字符串是否匹配模式,Class定义===来判断一个对象是否为类的实例,Symbol定义===来判断等号两边的符号对象是否相同。
(1..10) === 5 # true: 5属于range 1..10
/\d+/ === "123"  # true: 字符串匹配这个模式
String === "s" # true: "s" 是一个字符串类的实例
:s === "s" # true


===在大多数情况下用于case语句。
你还可以用=~来判断正则表达式的模式是否匹配。

(21)对象类和对象类型

有很多种方法可以获得一个对象的类是什么:
o = "test"  # 定义一个字符串值
o.class # 得到这个对象对于的类String



如果你想对类的集成结构感兴趣,你可以通过调用superclass方法获得:
o.class                       # String:o是一个字符串对象
o.class.superclass # Object: 字符串对象的父类是Object
o.class.superclass.superclass # nil: Object没有父类。

在Ruby1.9中Object不再是跟类:
Object.superclass             # BasicObject:在 1.9中Object的父类是BaseObject
BasicObject.superclass # nil: BasicObject 没有父类

那么,如果想比较一个对象的类是否为某个类,可以直接使用==操作:
o.class == String       # true 

instance_of? 可以完成相同的操作,这种做法看起来更简洁:
o.instance_of? String   # true

通常你可能希望判断一个对象是否是某个类的子类,你可以通过is_a?方法或者kind_of?方法:
x = 1                    # 定义一个对象
x.instance_of? Fixnum # true: 判断x是否是一个Fixnum
x.instance_of? Numeric # false: instance_of? 不能判断x是否为Numeric的子类
x.is_a? Fixnum # true
x.is_a? Integer # true
x.is_a? Numeric # true
x.is_a? Comparable # true: 是否实现了Comparable
x.is_a? Object # true 任何对象都是Object的子类

Ruby还定义了=== 操作符来完成is_a?相同的操作:
Numeric === x            # true: x is_a Numeric

在Ruby中我们通过不关心我们使用的对象的类型,我们只关心我们可以调用对象的那些方法,比如<<操作,在数组、字符串或者文件对象中,他意味着向对象增加内容,而对于整数对象,<<意味着对象的左位移操作。我们可以使用respond_to?方法来判断一个对象是否存在某个我们想要的方法。
o.respond_to? :"<<"  # 返回true,如果存在 << 操作。


但是这个方法的缺点是,你只知道有这样一个方法,但是你知道这个方法接受什么参数。比如对于整型<<期望的参数是一个整数,但是如果你给出的是一个字符串,那么这里会抛出异常。不幸的是,对此没有一个通用的解决方法,一个临时的方法是结合is_a?方法:
o.respond_to? :"<<" and not o.is_a? Numeric

(20)对象的唯一性

Ruby中所有的对象都有一个唯一的ID,你可以通过object_id方法获得对象的ID,在一个对象生命周期中,每一个对象ID都是不同的,唯一的。原来的id方法已经被废弃,如果你在Ruby1.8中调用这个方法你会得到一个警告信息,在Ruby1.9中这个方法被完全的删除了。
还有另外一个__id__方法与object_id实现同样的功能,如果你的object_id方法被重载了你可以通过这个方法获得对象ID

(19)Ruby中的对象

Ruby中一切都是对象,这里没有类似其他语言的原生类型和对象类型的区别,在Ruby中所有的对象都集成自Object。实际上当我们操作一个对象的时候我们实际上操作的是这个对象的引用,而不是对象本身,换句话说,当我们给一个变量赋值的时候我们并没有把值拷贝到这个变量“里边”,我们只是包存了一个引用到对象。如果你熟悉C或者C++你可以把对象引用理解为指针,但是Ruby其实没有实现指针。这里给出一些例子帮助我们理解对象引用:

s = "Ruby" # 创建一个字符串对象.  将一个引用存储到s.
t = s # 将这个引用拷贝给 t. 现在s和指向的是同一个引用.
t[-1] = "" # 通过对象t的引用修改这个对象.
print s # 通过 s访问这个已经更改的对象.打印值为 "Rub".
t = "Java" # 现在t指向另一个不同的引用.
print s,t # 打印结果为:"RubJava".


如果一个对象作为参数传递给一个方法,实际是传递的是对象的引用,而不是对象本身。更确切的说方法参数的传递是值传递而不是引用传递,但是这个值是对象的引用。这句话说起来比较拗口,再举个例子,比如你传递一个对象x给方法,而你在方法内容对传入的参数就行了修改,那么对象x的引用也被修改了:


def modify(x) #参数是一个对象引用的值
x[0]="H"
end
z="hello"
y=modify(z)
puts z #z:Hello,值被改为了

因为你传递的是对象的引用,那么方法就可以利用这个引用修改底层的对象,这个修改操作发生在方法返回的时候。
我们说Ruby中所有的对象操作都是通过引用实现的,但是Fixnum和Symbol型的对象是“不可变对象”,而且这些对象中也没有定义“改变其自身”的方法,所以我们没法说着两个对象是值传递还是引用传递。
创建一个类的实例需要通过new方法,new方法分配一个实际的内存空间来存储这个对象。当你执行new操作的时候会调用对象的initialize方法,这个方法负责初始化对象。
myObject = myClass.new

Ruby中不存在类似C和C++中的析构函数,Ruby会在必要的时候自动进行垃圾对象的回收,垃圾回收是由Ruby内部控制的,当一个对象不再使用,或者没有被其他对象引用,它就会被Ruby作为垃圾对象回收。自动垃圾回收机制可以有效的避免由于忘记释放内存而造成的内存泄漏,但这也不能保证你的程序永远没哟内存泄漏,假如你对字典对象时候了缓存机制,而由没有实现类似“最近访问”算法,那么这个对象会一直存在,或者你把一个很长的自动对象定义为全局变量,那么这个对象会一直存在,知道你的Ruby解析器退出。

(18)True, False, and Nil

就像我们前面章节中说到的那样Ruby中用true,false来表示布尔值,用nil表示空值。true是TrueClass类的实例,同样false是FalseClass的实例,nil是NilClass的实例,注意Ruby中没有Boolean这个类,TrueClass和FalseClass的超类就是Object。如果你想比较一个对象是否为空,你可以通过下面的方式:
o == nil # 对象o是空的吗?
o.nil?     # 另一种检测方式
在Ruby中没有1为true,0为false的说法,所有的对象如果为nil或者false那么就是false,其它情况都是true。

(17)Ruby中的Symbol

Symbol称为符号对象,它是由Ruby解析器维护的一个符号表,这个符号表中包含了所有已知的类、方法变量等,这主要是为了避免更多的内存开销。因为在Ruby中的字符串是可变对象,所以每一个字符串都是一个单独的对象即使是有相同内容的字符串他们在内存中的id也是不同的,比如:
s="hello"
puts s.object_id
s2="hello"
puts s2.object_id
你会发现他们的object_id是不同的,这和类似Java这样的语言处理方式是不同的,Java中的字符串是不可变对象,所以如果你在Java中定义两个相同内容的字符串,他们在内容中实际上是占用同一块内存地址。
那么Symbol的作用就是唯一标识一个名字,它占用唯一的一个内存地址。Symbol通过在一个唯一的标识符或者字符串前加冒号(:)来定义:
:symbol                   #定义一个Symbol
:"symbol" # 另一种方式
:'another long symbol' # 如果Symbol对象包含空格,可以用引号包含
s = "string"
sym = :"#{s}" # Symbol对象:string

就像String中使用%q和%Q定义字符串的方式,你也可以用%s加上任意的边界符号来定义一个Symbol。
%s[hello]     # 等同于 :hello

Symbol经常用于方法的反射机制,比如我们经常需要判断一个对象是否有each方法:
o.respond_to? :each

下面这个例子用于判断一个对象是否包含一个特定的方法,如果有,就调用它:
name = :size
if o.respond_to? name
o.send(name)
end

你可以通过intern或者to_sym将一个字符串转换为Symbol,反过来你可以使用to_s或者id2name方法将Symbol转换为字符串:
str = "string"     # 定义一个字符串
sym = str.intern # 转换为 symbol
sym = str.to_sym # 另一种转换方法
str = sym.to_s # 在转换回字符串
str = sym.id2name # 另一个转换成字符串的方法
最后我们来总结一下,拥有相同内容的字符串是不同的对象,但是拥有相同内容的字符串转换成的Symbol是一样的,不同的Symbol内容总是不同的。
如果你的程序中用到了字符串,而这个字符串可能表示的是一个唯一的内容,你应该考虑使用Symbol,所以如果你使用字典对象,那么最好用Symbol作为元素的“键”。
在Ruby1.9中增加了一系列String对象中的方法,比如length,size等等,你可以使用这种方式,实现类似不可变字符串的功能。