容器，块（ Blocks）和迭代器（ Iterator）

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

容器

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

数组Arrays

数组类包含了若干个对其它对象的引用，每个引用在数组的一个位置上，用一个正整数来索引。

你可以直接指定一组值来创建一个数组，或者用数组类的new方法。用第一种方法创建数组要用中括号把各个元素括起来，每个元素之间用逗号隔开。

数组指定索引的下标用[ ]操作符，这实际上也是一个方法，可以在子类中被重载。数组索引从0开始，从左向右技术，如果指定的索引为负数，则表示从右边开始计数（这时候最右边的索引下标为-1，不是0）。

你也可以一对数字[start, count]作为下标，这将返回一个数组，包含原数组中从start开始的count个元素。

    最后，你也可以在数组下标中使用Range作为索引。Range可参看下一章。Range的起始值之间如果是2个点号，则包括最后的结束值，如果是3个点号，则Range的值不包括最后的那个边界值。

[ ]方法有一个对应的 []= 方法，这个方法是用来给指定的位置设置新的值，如果数组的下标位置超过了数组的大小，那么指定的下标将被设为指定的值，而中间没有涉及到的位置为设为nil。如下面例子数组最大下标为4，而对a[6]设置新值，a[5]则被设为nil。

如果在[]= 方法中下标索引为两个数字（一个开始位置，一个长度）或者一个Range，则对应的一系列值将被重新设置。如果第二个参数即长度为0，则右边的值将被插入当前位置，没有值会被删除。如果[ ]=右边的长度和左边下标中指定的长度不一样，则原数组自动进行调整。

数组有很多有用的方法，使用这些方法你能用数组实现队列，堆栈，列表等各种数据结构。

哈希Hashes

Implementing a SongList Container

append( aSong ) ? list

Append the given song to the list.

deleteFirst() ? aSong

Remove the first song from the list, returning that song.

deleteLast() ? aSong

Remove the last song from the list, returning that song.

[ anIndex } ? aSong

Return the song identified by anIndex, which may be an integer index or a song title.

class SongList
  def initialize
    @songs = Array.new
  end
end

class SongList
  def append(aSong)
    @songs.push(aSong)
    self
  end
end

class SongList
  def deleteFirst
    @songs.shift
  end
  def deleteLast
    @songs.pop
  end
end

list = SongList.new
list.
  append(Song.new('title1', 'artist1', 1)).
  append(Song.new('title2', 'artist2', 2)).
  append(Song.new('title3', 'artist3', 3)).
  append(Song.new('title4', 'artist4', 4))

class SongList
  def [](key)
    if key.kind_of?(Integer)
      @songs[key]
    else
      # ...
    end
  end
end

块和迭代器Blocks and Iterators

下面，我们要在SongList中修改[ ] 方法，使它能接受一个字符串参数，返回以此为标题的歌曲的。看起来我们很容易可以实现：我们有一个包含了很多Song对象的对象的数组，我们只需循环遍历整个数组，找到匹配的那个就可以了。

class SongList
  def [](key)
    if key.kind_of?(Integer)
      return @songs[key]
    else
      for i in 0...@songs.length
        return @songs[i] if key == @songs[i].name
      end
    end
    return nil
  end
end

这样已经可以工作了，而且看上去很符合常规：用一个for循环来遍历数组。

有没有更自然的方法呢？

当然有，我们可以用Array的find方法。

class SongList
  def [](key)
    if key.kind_of?(Integer)
      result = @songs[key]
    else
      result = @songs.find { |aSong| key == aSong.name }
    end
    return result
  end
end

我们可以用if修饰符来使代码更简短一些。

class SongList
  def [](key)
    return @songs[key] if key.kind_of?(Integer)
    return @songs.find { |aSong| aSong.name == key }
  end
end

方法find就是一个迭代器，这个方法重复不断地执行一个给定的block。块和迭代器都是Ruby中比较有趣的特点。我们后面会进一步来讨论这些特点。

实现迭代器

一个Ruby迭代器就是一个简单的能接收代码块的方法。第一眼看上去，Ruby中的block像C，Java，Perl中的一样，但是实际上是有不同的。

首先，块在源代码中紧挨着方法调用，并且和这个方法的最后一个参数写在同一行上。其次，这个块不会立即被执行，Ruby首先会记住这个块出现的上下文（局部变量，当前对象等），然后进入方法，这里也是魔术开始的地方。

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

def threeTimes
  yield
  yield
  yield
end
threeTimes { puts "Hello" }

Hello
Hello
Hello

这个块（用两个大括号定义）赋给了一个方法threeTimes，在这个方法里面，yield执行了3次，每次执行它都会调用给定的block，即打印一个欢迎语句。使块变得有趣的是你可以给块传递参数，并且从块中得到结果。下面例子，我们将会得到小于一个指定值得Fibonacci 数列。

def fibUpTo(max)
  i1, i2 = 1, 1        # parallel assignment
  while i1 <= max
    yield i1
    i1, i2 = i2, i1+i2
  end
end
fibUpTo(1000) { |f| print f, " " }

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

在这个例子中，yield接收一个参数，这个参数将会在执行的时候传递给指定的块。在块的定义中，参数用两个竖线括起来，放在最前面。在这个例子中f用来接收yield传递的参数，所以，这个块才能打印这个序列。一个块可以接受任意个参数。如果一个块的参数和yield中传递的参数个数不一样，将会怎样呢？很巧合，这和我们在并行赋值（parallel assignment）中谈到的原则一样（如果一个block只接收一个参数，而yield提供的参数多于1个，那么这些参数将被转化为一个数组。）

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

这个用法中数组将连续的元素传递给指定的块，如果这个块返回true，则这个方法返回当前对应的元素值，如果没有符合的值，则返回nil。这个方法显示了迭代器的好处，Array类只作自己应该做的，访问数组元素，而应用代码只关注于特殊的需求。

Ruby中的集合对象中也包含其它一些常用迭代器，其中之二是each和collect。each可以认为是最简单的迭代器，它们都会对集合的每个元素来调用块。

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

1
3
5

另一个是collect，它跟each类似，它将集合中的元素传递给一个块，在块中处理后返回一个包含处理结果的新数组。

Ruby 和 C++ 、 Java的比较

这值得我们再花一些时间来比较一下Ruby，C＋＋,JAVA中的迭代器。在Ruby中，迭代器是一个简单的方法，每当它产生一个新值，都会调用yield方法。使用迭代器只需要给这个迭代器传递一个块，不需要像C＋＋，Java中那样创建辅助类来处理迭代器的状态。从这一点和其它一些特点来说，Ruby是一种透明语言，当你写程序的时候，你只需关注于让功能能够实现，而不必编写脚手架来支持语言的一些功能。

f = File.open("testfile")
f.each do |line|
  print line
end
f.close

This is line one
This is line two
This is line three
And so on...

让我们再看看另外一个迭代器实现。Smalltalk也支持迭代器，如果你用smalltalk语言来计算一个数组中元素的和，可以这样：

sumOfValues              "Smalltalk method"
    ^self values
          inject: 0
          into: [ :sum :element | sum + element value]

Ruby 没有inject 方法，但我们可以很容易的写一个，在这个例子中我们把它加入Array类。

尽管block经常是用在迭代器中，但是，块也有其它一些有用的用处。

在事务处理中使用块

block也可以用作定义一块代码，这些代码必须在一定的事务控制下运行。比如，你经常会打开一个文件，对内容作一些处理，然后需要确保文件在最后会被关闭。尽管我们可以用常规的方法实现，但是，我们可以让文件对象自己负责关闭它。一个简单例子如下（忽略了错误处理等）：

class File
  def File.openAndProcess(*args)
    f = File.open(*args)
    yield f
    f.close()
  end
end


File.openAndProcess("testfile", "r") do |aFile|  
  print while aFile.gets  
end
   

This is line one
This is line two
This is line three
And so on...

这个小例子阐述了几个技术点。方法openAndProcess 是一个类方法，这个方法可以独立于任何File对象来单独调用，即不需要生成类的实例。我们在这个方法的参数列表中使用了 *args，这表示所有调用时候的参数将作为数组传递到这个方法。而这个参数是传递给File.open方法的。

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

最后，这个例子用do..end来定义一个块，这和用两个打括号定义一个块只是有优先级别的区别，将在后面讨论。

让文件自己管理自己的生命周期十分有用，Ruby自带的File类就提供了这样的支持。如果File.open调用时指定了一个block，那么这个块就会用传递过来文件对象作为参数执行，然后，当块结束后，这个文件会被文件对象关闭。这很有趣，也就是说File.open方法有两个版本，一个接受block，一个不接受block。当没有指定block调用这个方法的时候，这个方法只会返回一个打开的文件对象。方法Kernel::block_given?提供了实现这种功能的可能，如果调用的时候给了一个block，这个方法将返回true，这样，你也可以实现自己open方法：

class File
  def File.myOpen(*args)
    aFile = File.new(*args)
    # If there's a block, pass in the file and close
    # the file when it returns
    if block_given?
      yield aFile
      aFile.close
      aFile = nil
    end
    return aFile
  end
end

块和闭包

让我们再回来看看自动点唱机，某些时候，我们需要处理点唱机和用户的界面：很多按钮，供用户选择歌曲和控制播放，我们需要给这些按钮指定相应的时间处理代码，而Ruby中的block就很适合干这样的事情。假设点唱机的设计者通过Ruby扩展为我们提供了一个基本的按钮类。

bStart = Button.new("Start")
bPause = Button.new("Pause")
# ...

当用户按下按钮之后如何处理呢？Button类提供了一个buttonPressed方法，在按钮按下时能被回调。所以最简单的方法创建Button的子类，然后在每个子类中实现buttonPressed 方法。

class StartButton < Button
  def initialize
    super("Start")       # invoke Button's initialize
  end
  def buttonPressed
    # do start actions...
  end
end

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

class JukeboxButton < Button
  def initialize(label, &action)
    super(label)
    @action = action
  end
  def buttonPressed
    @action.call(self)
  end
end

 
bStart = JukeboxButton.new("Start") { songList.start }   
bPause = JukeboxButton.new("Pause") { songList.pause }
 

上面代码的关键点在JukeboxButton#initialize的第二个参数，这个参数前面带有一个&符号，在Ruby中代表这个参数是一个块，这个块将会被转化为一个Proc对象，并关联道相应变量。在本例中我们把它赋给实例变量@action 。当回调方法buttonPressed 执行时，我们用方法Proc#call来调用相应的block。

我们来看一个例子，这个例子用了方法proc，这个方法把一个block变为了一个Proc对象。

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