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."