How to Use Loops in Ruby

Computer programs often have to perform actions a number of times, not just once. For example, a program that prints all of your new email will need to print each email from a list, not just a single email. To do this, constructs called loops are used. A loop will repeat the statements inside it a number of times until some condition is met.

While Loops

The first type of these loops is a while loop. While loops will execute all of the statements contained within them as long as the conditional statement remains true. In this example, the loop continually increases the value of the variable i by one. As long as the conditional statement i < 10 is true, the loop will continue executing the statement i += 1 which adds one to the variable.

#!/usr/bin/env ruby
i = 0
while i < 10
i += 1
end
puts i

Until Loops

Until loops are almost identical to while loops except that they will loop as long as the conditional statement is false. The while loop will loop while the condition is true, the until loop will loop until the condition is true. This example is the functional equivalent of the while loop example, except using an until loop, until i == 10 . The variable is incremented by one until its value equals ten.

#!/usr/bin/env ruby
i = 0
until i == 10
i += 1
end
puts i

Loops the "Ruby Way"

Though the more traditional while and until loops are used in Ruby programs, closure-based loops are more common. It isn't even necessary to understand what closures are or how they work in order to use these loops; in fact, they're viewed as normal loops despite being very different under the hood.

The Times Loop

The times loop can be used on any variable containing a number or used on a number itself. In the following example, the first loop is run 3 times and the second loop is run however many times is input by the user. If you input 12, it would run 12 times. You'll notice that the times loop uses the dot syntax (3.times do) rather than the keyword syntax used by the while and until loop. This has to do with how the times loop works under the hood but it's used in the same way a while or until loop is used.

#!/usr/bin/env ruby
3.times do
puts "This will be printed 3 times"
end
print "Enter a number: "
num = gets.chomp.to_i
num.times do
puts "Ruby is great!"
end

The Each Loop

The each loop is perhaps the most useful of all the loops. Each loop will take a list of variables and run a block of statements for each of them. Since almost all computing tasks use lists of variables and have to do something with each of them in the list, the each loop is by far the most common loop in Ruby code. One thing to note here is the argument to the loop's block of statements. The value of the current variable the loop is looking at is assigned to the variable name in pipe characters, which is |n| in the example. The first time the loop runs, the n variable will be equal to "Fred," the second time the loop runs it will be equal to "Bob" and so on.

#!/usr/bin/env ruby
# A list of names
names = [ "Fred", "Bob", "Jim" ]
names.each do|n|
puts "Hello #{n}"
end