Design Patterns in Ruby [Digest 6] Iterator

The Iterator pattern is a technique that allows an aggregate object to provide the outside world with a way to access its collection of subobjects.

In Java we use java.util.Iterator interface to be implemented.

eg. StringTokenizer ResultSet

In Ruby We can write Iterator:

 

class ArrayIterator
  def initialize(array)
    @array = array
    @index = 0
  end
  def has_next?
    @index < @array.length
  end
  def item
    @array[@index]
  end
  def next_item
    value = @array[@index]
    @index += 1
    value
  end
end

 

 

array = ['red', 'green', 'blue']
i = ArrayIterator.new(array)
while i.has_next?
   puts("item: #{i.next_item}")
end

 

The Internal Iterator is:

def for_each_element(array)
  i = 0
  while i < array.length
    yield(array[i])
    i += 1
  end
end

 There are some differences between the two implementations:

external version will be easier to control the process:

"With an external iterator, you won’t call next until you are good and ready for the next element. With an internal iterator, by contrast, the aggregate relentlessly pushes the code block to accept item

after item."

 

"A second advantage of external iterators is that, because they are external, you can share them—you can pass them around to other methods and objects."