until loops. We’ll also take a quick look at plain old loops and the
break keyword, which we can use to break out of a loop at any time.
One of the most basic loops in Ruby is the
times loop. Here's an example:
> number = 0 > 5.times() do number = number + 1 end => 5
times loop will run the number of times we specify, which is 5 times in this case. Each time through the loop,
number is incremented by 1.
There's one other thing to note here: we're not defining a method. Instead, we're just passing a block to the
times method. We always need to pass a block with instructions (code) to our loops. The block begins with
do and finishes with
If we wanted, we could pass an argument into a
times loop like this:
5.times do |t|. (We can name the parameter whatever we like.) The value of
t each time through the loop is the number of times the loop has run (the index of the loop), starting with with
This kind of loop isn't very common, but there are times when you'll find it useful. The
each loop, on the other hand, is probably the most common and useful looping technique in Ruby.
Each loops are particularly useful for looping through collections. A collection could be an array, range or hash (which we haven't covered yet). Let's say we want to multiply each value inside an array by 2. We’ll create a method called
array_doubler to do this.
def array_doubler(array) new_array =  array.each do |array_element| new_array.push(array_element * 2) end new_array end > array_doubler([1,2,3]) => [2,4,6]
We start by passing an array of values into our
array_doubler method. Before we iterate over the values, though, we create a new array. In this case, the
each loop won't actually modify the receiver, so we’ll need to push the values into the new array. A common mistake for beginners is assuming that methods inside a loop will change the receiver. Sometimes that's the case, such as with bang methods, but sometimes we need to push the values into a new array as we do above.
Just like with the
times loop, we also use slightly different syntax to pass an argument into our
each loop. Instead of parentheses, we surround our parameter with
| symbols. (We'll get an error if we use parentheses.) An each loop should always have the following syntax:
collection.each do |element|.
array_doubler method, the
each loop iterates through each element in the
array, passing the element into our
array_element parameter one at a time. We double the
array_element and then push that value into
new_array. Finally, when the loop is done, we implicitly return
We can also iterate over other collections, so let’s look at an example of using
each to iterate over a range.
> numbers = (1..10) > sum = 0 > numbers.each() do |number| sum = sum + (number) end > sum => 55
You’ll be using
each loops very regularly in Ruby, so take the time to practice creating some methods with loops on your own!
while loop runs while a condition is true. An
until loop runs until a condition becomes false. It’s very important that you choose a condition that will eventually be met; otherwise, you’ll have an infinite loop.
Here’s an example of a
> x = 0 > array =  > while (x < 10 ) x = x + 1 array.push(x) end > array => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
while loop continues as long as
x is less than 10. So why does our final array include the element
10 at the end? The last time through the loop,
9. We increment
x by 1 and
10 is pushed to the array.
You’ll also notice that we’ve declared
array outside of the loop. If
x were declared inside the loop, the value of
x would never be greater than 1 and we’d end up with an infinite loop. If
array were declared inside the loop, it would be reinitialized as
 each time we went through the loop and the final result would be an empty array.
These are common errors you’ll encounter with looping in general, especially at the beginning, so always make sure to declare these variables outside of the loop.
until loop is essentially the opposite of a
while loop. We could easily rewrite the loop above with an
until loop instead.
x = 0 array =  until (x >= 10 ) x = x + 1 array.push(x) end array => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
If you’re making a choice between a
until loop, opt for the clearest and most readable of the two.
Let’s cover one last loop. You won’t see this one very much but you should still be aware of it. We’ll also take a look at the
break keyword, which we can use in any loop. We can create a simple loop without conditions by using
Here’s an example. Be ready to use
c to escape if you try it out.
loop do puts "hi" end
puts logs information to the REPL. In this case,
If you run this loop, it will run the loop indefinitely. The only way to escape is to force it to quit. This kind of loop may not seem very useful, and it’s certainly less flexible than other Ruby loops, but we can make it more workable with the
break keyword terminates a loop and we can use it with any Ruby loop. Here’s an example of how we could use
break to output
hi to the terminal ten times.
> counter = 0 > loop do counter += 1 if counter > 10 break end puts "hi" end hi hi hi hi hi hi hi hi hi hi => nil
Since our loop doesn't actually return anything, we get a return value of
Counters are very, very common in programming languages, and we use one here. Each time through the loop, we increment our loop by one. We’re using shorthand here;
counter += 1 is the same as
counter = counter + 1.
If the counter is greater than
10, our loop will break. If not,
hi will be outputted to the terminal.
You probably won’t use plain old loops much, but the
break keyword can be very useful.
In this lesson, we’ve covered the basics of looping in Ruby. Most of the time you’ll use
each loops, but
until loops can also be very useful. And while you’re less likely to use a plain old
loop or a
times loops, they can still come in handy. We’ve also covered the
break keyword, which can be used any time you need to break out of a loop. And with that, it’s time to break away from loops, at least for now!
number = 0 5.times() do number = number + 1 end
def array_doubler(array) new_array =  array.each do |array_element| new_array.push(array_element * 2) end new_array end
Here’s an example of a
x = 0 array =  while (x < 10 ) x = x + 1 array.push(x) end
Here's an example of an
x = 0 array =  until (x >= 10 ) x = x + 1 array.push(x) end
counter = 0 loop do counter += 1 if counter > 10 break end puts "hi" end
Lesson 6 of 10
Last updated August 7, 2022