Ruby 语句与控制结构

迭代器和可枚举对象

迭代器的描述并不准确，像”期待一个关联代码块的方法“这样的描述更加准确一些。迭代器是 Ruby 的重要特性之一。当程序执行时，遇到迭代器总的 yield 语句时，程序控制流会从迭代器转移到那个与迭代器想关联的代码块中，程序执行完代码块之后，迭代器方法重新获得控制权并从 yield 语句之后的第一条语句开始执行。

yield 语句像一个方法调用，后边可以接零个或多个参数，这些值将会赋给对应的代码块的形参。

block_given?（同义词 iterator? ）方法可以判断是否在调用该方法时带有一个代码块，它们都是 Kernel 模块定义的，所以表现的像全局函数一样。

可枚举对象

Array、Hash、Range 和许多其他的类都定义了 each 迭代器。大多数定义了 each 迭代器的类都包含了 Enumerable 模块，它定义了许多更加特殊的迭代器，而它们都是基于 each 方法来实现的。其中包括 each_with_index、collect（也被称为 map ）、select、reject 和 inject 等等。

枚举器

枚举器是 Enumerable::Enumerator 的实例，其目的在于枚举其他对象。虽然可以通过 new 操作符直接实例化这个类，但是通常情况下，我们并不会通过这种方式来创建枚举器，而是使用 Object 类的 to_enum 或其同义词 enum_for。

如果调用的时候没有提供参数，那么这个枚举器的 each 方法只是简单的调用目标对象的 each 方法。例如，你有一个数组和一个方法，该方法期望一个可枚举对象。因为数组可变，而且你不确定该方法是否会修改该数组，所以不想直接将数组传递给该方法。为了达到这个目的，与其创建一个该数组的深度防御拷贝，还不如直接调用它的 to_enum 方法。

process(data.to_enum)

你也可以给 to_enum 或 enum_for （显得更自然一些）方法传递参数，第一个参数应该是一个符号，表示了一个迭代器方法（来自原先的对象）。这个返回的迭代器的 each 方法会调用那个迭代器方法。例如，在 Ruby1.9 中，String 类不是 Enumerable 的，但是它具有3个迭代器方法： each_char（同名 chars ），each_byte 和 each_line 。但如果我们想使用一个 Enumerable 方法，比如 map，而且基于 each_char 迭代器。我们可以这样创建一个迭代器：

s = "hello"
s.enum_for(:each_char).map { |c| c.succ }    # ["i", "f", "m", "m", "p"]

在 Ruby1.9 中，通常都不用显式的使用 to_enmu 和 enum_for，因为以不带代码块的方式调用内建的迭代器方法时（包括数值迭代器、each 和 Enumerable 相关方法时），它们都会自动的返回一个枚举器。因此上边的连个例子可以修改为：

 process(data.each)

s="hello"
s.chars.map{ |c| c.succ }

当以不带代码块的方式调用自己的迭代器时，可以通过返回 self.to_enum 的方法来实现上述行为。

def twice
  if block_given?
    yield
    yield
  else
    self.to_enum(:twice)
  end
end

Ruby1.9 中还定义了 with_index 方法，它只是返回一个新的枚举器，为迭代添加索引形参。

s = "hello"
enumerator = s.each_char.with_index

enumerator.each do |char, index|
  puts index.to_s + " " + char
end

外部迭代器

在 Ruby1.9 中迭代器还有一个重要作用就是外部迭代器： 外部迭代器。你可以通过反复调用一个枚举器的 next 方法来遍历一个集合的元素。

iterator = 9.downto(1)
begin
  print iterator.next while true
rescue StopIteration
  puts "...blastoff!"
end

外部迭代器的使用很简单，每次需要另一个元素时调用 next 方法即可，遍历完元素之后，next 抛出一个 StopIteration 异常。

Kernel.loop 方法包含了一个隐式的 rescue 从句，而且在 StopIteration 抛出时干净利落的退出循环。前边例子可以改写如下：

iterator = 9.downto(1)
loop do
  print iterator.next
end
puts "...blastoff!"

使用 rewind 方法可以是许多外部迭代器重新开始迭代，但是如果一个迭代器像 File 这样从文件中顺序读入行的对象，那么调用 remind 方法并不能使其重新开始迭代。总的来说，如果调用底层 Enumeralbe 对象的 each 方法并不能使其重新开始迭代，那么调用rewind 的方法也不会有效。

一个外部迭代器一旦启动（第一次调用 next 方法之后），就不能在克隆和赋值该迭代器。可以克隆一个迭代器的典型时机是：next 被调用之前、StopIteration 被抛出之后，或者在 rewind 被调用之后。

外部迭代器比内部迭代器更加灵活，它们可以解决两个迭代器的并行迭代的问题。

代码块

代码块的值

一个代码块的“返回值”就是它最后边执行那个表达式的值。一般来说，你不应该将使用 return 关键字来从代码块中返回。一个位于代码块中的 return 将会导致包含该代码块的那个方法返回。如果你希望指定一个代码块的返回值应该使用 next。

变量作用域

代码块定义了一个新的变量作用域，但是在一个作用域中定义的局部变量，在该作用域中所有的代码块中都可见。

total = 0
data = [1, 2, 3]
data.each { |x| total += x }
puts total

从 Ruby1.9 开始，代码块的形参作用域范围始终都在代码块内。如果使用 -w 选项，那么当一个代码块形参和一个已经存在的变量重名时，它就会发出警告。另外，你也可以声明块级局部变量，如下：

x = y = 0
1.upto(4) do |x;y|
  y = x + 1
  puts y*y
end
[x, y]    # [0, 0]

传递实参

Ruby1.9 使代码块形参作用域范围严格的局部于代码块本省，这就意味着，全局或实例变量不再是合理的代码块形参了。

与方法调用比起来，yield 关键字后边的实参值传递给代码块形参的给类似于并行赋值规则，但是也部完全一样。如果一个迭代器将两个值传递给它的代码块，但是代码块只接受一个参数，Ruby 并不会像并行赋值一样将两个参数合并成为一个数组。

def two
  yield 1, 2
end

two{ |x| p x }    # 1
two{ |*x| p x }    # [1, 2]
two{ |x,| p x }    # 1

和并行赋值一样，1.9中，无论代码块形参在参数列表的什么位置，都可以具有一个 * 前缀。

和方法调用一样，yield 也允许不带花括号的哈希作为其最后一个参数。

1.9中，最后一个代码块形参可以具有一个 & 前缀，表示它将接受与该代码块相关的任何代码块。

代码块形参和方法形参有一个重要的区别就是，代码块形参不允许有默认值。一种创建 proc 对象的字面量语法才允许有默认值。

[1, 2, 3].each &->(x, y=10) { print x*y }

改变控制流

return

当 return 语句位于一个代码块的时候（无论嵌套多深），它总会使得外围的方法返回，即它不仅会使得代码块返回，还会使得调用代码块的那个迭代器返回，而且它还会使得外围方法返回。

def find(array, target)
  array.each_with_index do |element, index|
    puts "haha"
    return index if (element == target)
  end
  nil
end

值得注意的是，普通代码块和 lambda 表达式中的 return 行为并不一致。

break

当被用在一个代码块中时，break 不仅将控制权传递出代码块，而且传递到调用代码块的迭代器之外。和 return 不一样，break 并不会使外围方法返回。

arr = [1, 2, 3, 4, 5]
arr.each do |i|
  break if i == 4
  puts i
end

break 只能出现在一个词法上外围循环或代码块里，其他任何上下问使用 break 都会导致一个 LocalJumpError。

break 可以为他所跳出的循环或迭代器指定一个值。如果 break 表达式后边没有表达式，那么循环表达式和迭代器的返回值就是 nil。

next

next 语句使一个循环或迭代器结束当前的迭代，开始下一轮迭代。当用在一个代码块里的时候，next 使代码块立即结束，将控制权返回给迭代器的方法。

next 后边也可以接一个表达式，当用在一个循环当中，next 之后的任何值都会被忽略。当用在代码快中时，next 之后的值会被当作 yield 语句的返回值。

redo

redo 将控制权传递到循环或代码块的开头，重新开始当前迭代。它不会重新测试循环条件，也不会获取迭代器的下一个元素。redo 语句并不是一个常用语句，它一种用法是从用户输入错误中恢复过来。

puts "Please enter the first word you think of"
words = %w(apple banana cherry)
response = words.collect do |word|
  print word + "> "
  response = gets.chop
  if response.size == 0
    word.upcase!
    redo
  end
  response
end

throw 和 catch

throw 和 catch 是 Kernel 模块的方法。throw 不仅可以跳出当前循环或代码块，而且可以向外跳出任意数量级，使与 catch 一同定义的代码块退出。

下面展示了如何“跳出”嵌套循环：

for matrix in data do
  catch :missing_data do
    for row in matrix do
      for value in row do
        throw :missing_data unless value
        puts "#{value}"
      end
    end
  end
end