Ruby's Loops

The Ruby programming language has many ways to do what you want. For example, it has no fewer than nine types of loops. Here I have each loop, and how you would express it in C. For some of these, I made up the names. And sometimes I called them loops when they are actually iterators. But I can do that if I want to.

0. Basic loop
Since this loop is just a basic loop, it starts with 0.

loop
    expression
end

It will just keep going until the loop is broken out of somehow. In C, it would be written like this:

while (true) {
    expression
}

1. While loop

while (statement)
    expression
end

This loop is rather simple, and has a very close C equivalent:

while (statement) {
    expression
}

2. Until loop

until (statement)
    expression
end

This may seem rather useless, since it is very similar to a while loop. But it increases readability, and readability is always good. In C it looks like this:

while (!(statement)) {
    expression
}

3. For loop

for var in start..end
    expression
end

This is intuitive and understandable. It is very much like the Python for loop. Its C equivalent is this:

for (var = start; var < end; var++) {
    expression
}

4. Each loop

(start..end).each { |var|
    expression
}

This as well is very intuitive, and represents a different way to do the same thing as #3.

5. Each_index loop

array.each_index { |var|
    expression
}

This allows you to quickly go through an array without knowing how long it is. In C, it gets ugly:

for (var = 0; var < sizeof(array)/sizeof(int); var++) {
    expression
}

The above C code only works in the array is filled with integers.

6. Times loop

(number).times { |var|
    expression
}

This is my favorite one. It’s just so elegant. In C, it would be done like this:

for (var = 0; var < number; var++) {
    expression
}

7. Upto loop

(start).upto(end) { |var|
    expression
}

Another beautifully intuitive loop. I’ve never used this one since I prefer the for loop, but it’s in the toolbox if you ever want it.

8. Step loop

(start).step(end, size) { |var|
    expression
}

This is a simple and once again intuitive loop that is much less intuitive in C.

for (var = start; var < end; var += size) {
    expression
}

What a wonderful world is the world of Ruby loops and iterators.

About these ads