![]() Prev |
![]() Contents |
![]() Next |
Ruby user's guide | Iterators |
Iterators are not an original concept with ruby. They are in common use in object-oriented languages. They are also used in Lisp, though there they are not called iterators. However the concepet of iterator is an unfamiliar one for many so it should be explained in more detail.
The verb iterate means to do the same thing many times, you know, so an iterator is something that does the same thing many times.
When we write code, we need loops in various situations. In
C, we code them using for
or while
. For example,
char *str; for (str = "abcdefg"; *str; str++) { /* process a character here */ }
The for(...)
is a sort of idiom, but it requires
knowledge of internal data from us. Requiring a programmer to
know about internal structure when in a simple loop makes C feel like
a low-level language. Some higher level languages have control
structures for iteration. Consider the following example of
sh
. (You may ask, "Is sh
higher than
C?" Ok, it seems so at least in this example...)
for i in *.[ch]; do # something to do for each file done
In this case, sh
undertakes the details of picking up and
substituting file names one by one. I think this is working at a
higher level than C, don't you?
But there are is more to consider: while it is fine for a language to provide iterators for built-in data types, it is a disappointment if we must go back to writing low level loops to iterate over our own data types. In OOP, users often define one data type after another, so this could be a serious problem.
So every OOP language includes some facilities for iteration. Some languages provide a special class for this purpose; ruby allows us to define iterators directly.
Ruby's String
type has some useful iterators:
ruby> "abc".each_byte{|c| printf "<%c>", c}; print "\n" <a><b><c> nil
each_byte
is an iterator for each character in the
string. Each character is substituted into the local variable
c
. This can be translated into something that looks
a lot like C code ...
ruby> s="abc";i=0 0 ruby> while i<s.length | printf "<%c>", s[i]; i+=1 | end; print "\n" <a><b><c> nil
... however, the each_byte
iterator is both conceptually
simpler and more likely to continue to work even if the
String
class happens to be radically modified in the
future. One benefit of iterators is that they tend to be robust
in the face of such changes; indeed that is a characteristic of good
code in general. (Yes, have patience, we're about to talk about
what classes are, too.)
Another iterator of String
is each_line
.
ruby> "a\nb\nc\n".each_line{|l| print l} a b c nil
The tasks that would take most of the programming effort in C (finding line delimiters, generating substrings, etc.) are easily tackled using iterators.
The for
statement appearing in the previous chapter does
iteration by way of an each
iterator.
String
's each
works as same as
each_line
, so let's rewrite the above example with
for
:
ruby> for l in "a\nb\nc\n" | print l | end a b c nil
We can use a control structure retry
in conjunction with
an iterated loop, and it will retry the current iteration of the loop
from the top.
ruby> c=0 0 ruby> for i in 0..4 | print i | if i == 2 and c == 0 | c = 1 | print "\n" | retry | end | end; print "\n" 012 01234 nil
yield
occurs sometimes in a definition of an
iterator. yield
moves control to the block of code
that is passed to the iterator (this will be explored in more detail
in the chapter about procedure
objects). The following example defines an iterator
repeat
, which repeats a block of code the number of times
specified in an argument.
ruby> def repeat(num) | while num > 0 | yield | num -= 1 | end | end nil ruby> repeat(3) { print "foo\n" } foo foo foo nil
With retry
, one can define an iterator which works the
same as while
, though it's too slow to be practical.
ruby> def WHILE(cond) | return if not cond | yield | retry | end nil ruby> i=0; WHILE(i<3) { print i; i+=1 } 012 nil
Do you understand what an iterator is? There are a few restrictions, but you can write your original iterators; and in fact, whenever you define a new data type, it is often convenient to define suitable iterators to go with it. In this sense, the above examples are not terribly useful. We will talk about practical iterators after we have a better understanding of what classes are.
![]() Prev |
![]() Contents |
![]() Next |