Using loops and iterators, Ruby can automate repetitive tasks for you quickly and easily.

Loops & Iterators

The `.times` method is like a super compact `for` loop: it can perform a task on each item in an object a specified number of times.

For example, if we wanted to print out `"Chunky bacon!"` ten times, we might type
```rb
10.times { print "Chunky bacon!" }
```
We don't know why we would type that, but we could!

The .times Iterator

We've been using syntax like `counter = counter + 1`, which works, but as you'll increasingly find with Ruby, there's always another way.

A shortcut is to use an *assignment operator*. You already know one assignment operator: `=`, which sets a variable. You can update a variable with additional assignment operators, however, which include `+=`, `-=`, `*=`, and `/=`. For instance, when you type 
```rb
counter += 1
```
You're telling Ruby: "Add 1 to `counter`, then assign that new value back to `counter`." This provides a succinct way of updating variable values in our programs.

Some languages have the increment operators `++` and `--` (which also add or subtract 1 from a value), but Ruby does not. You'll have to make do with `+=` and `-=`!

More Assignment Operators

In case you're not picking up on the theme of Ruby having a gajillion ways to do any given task: let's convert our loop yet again.

```rb
for k in 1..3
  print k
end
```

In the above example, we print out `123` by virtue of looping from `1` to `3` inclusive.

Looping with 'For'

Did you see that? The loop printed out the numbers 1 to 10, then stopped. This was because the loop's condition said to continue while `counter` was less than 11; since `counter` went up by 1 each time through the loop, the loop stopped when `counter` hit 11.

What if we'd forgotten to increment `counter`? It would have stayed at 1, the loop would have kept checking to see if it was less than 11 (and 1 is always less than 11), and the loop would never have ended. This is called an *infinite loop* and it will cause your programs to crash. Avoid them at all costs!

Danger: Infinite Loops!

Let's say we want to save a range of numbers in a variable. How would we do this? A variable can only hold a single value, right?

In Ruby, we can pack multiple values into a single variable using an *array*. An array is just a list of items between square brackets, like so: `[1, 2, 3, 4]`. The items don't have to be in order—you can just as easily have `[10, 31, 19, 400]`.

Saving Multiple Values

Okay, training wheels off. Let's see your stuff!

```rb
i = 3
while i > 0 do
  print i
  i -= 1
end
```

1. In the above example, we create a variable called `i` and set it to `3`.
2. Then, we print out `321` since we execute the loop as long as `i` is positive.

Looping with 'While'

Great work! We'll give you a bit of a break from the numbers game.

```rb
m = 0
loop do
  m += 1
  print m
  break if m == 10
end
```

In the example above, we print out `12345678910` since we loop 10 times.

Loop the Loop with Loop

Finally, let's replace our `loop` with the `.times` iterator.

Iterating with .times

Good work! You're ready to build your very own `for` loop.

Building Your Own

Sometimes you want to repeat an action in Ruby while a certain condition is true, but you don't know how many times you'll have to repeat that action. A good example would be prompting a user for a certain type of input: if they insist on giving you the wrong thing, you may have to re-ask them several times before you get the kind of input you're looking for.

To accomplish this, we use something called a `while` loop. It checks to see if a certain condition is true, and `while` it is, the loop keeps running. As soon as the condition stops being true, the loop stops!

The 'While' Loop

You saw a bit of new syntax in the previous exercise: `for num in 1...10`. What this says to Ruby is: "For the variable `num` in the range `1` to `10`, do the following." The following was to `puts "#{num}"`, so as `num` took on the values of 1 to 9, one at a time, those values were printed to the console.

The reason this program counted to 9 and not 10 was that we used three dots in the range; this tells Ruby to exclude the final number in the count: `for num in 1...10` means "go up to but don't include `10`." If we use two dots, e.g. `for num in 1..10`, this tells Ruby to include the highest number (`10`) in the range.

Inclusive and Exclusive Ranges

Good work!

```rb
i = 3
while i > 0 do
  print i
  i -= 1
end

j = 3
until j == 0 do
  print j
  j -= 1
end
```

In the example above, we wrote the same loop using `while` and using `until`.

Looping with 'Until'

So far we've learned one way to repeat an action in Ruby: using loops. As is often the case in Ruby, however, there's more than one way to accomplish a given task. In this case, it's also possible to repeat an action using an *iterator*.

An iterator is just a Ruby method that repeatedly invokes a block of code. The code block is just the bit that contains the instructions to be repeated, and those instructions can be just about anything you like!

The simplest iterator is the `loop` method. You can create a basic (but infinite!) loop by simply typing
```rb
loop { print "Hello, world!" }
```
In Ruby, curly braces (`{}`) are generally interchangeable with the keywords `do` (to open the block) and `end` (to close it). Knowing this, we can write a smarter loop than the one above:
```rb
i = 0
loop do
  i += 1
  print "#{i}"
  break if i > 5
end
```

The `break` keyword is our Get Out of Jail Free card: it breaks a loop as soon as its condition is met.

The Loop Method

The complement to the `while` loop is the `until` loop. It's sort of like a backward `while`:

```rb
i = 0
until i == 6
  i = i + 1
end
puts i
```

1. In the example above, we first create a variable `i` and set it to `0` (zero).
2. Then we execute a block of code until `i` is equal to `6`. That block of code increments `i`.
3. When `i` is equal to `6`, the block ends.
4. Finally, we print `6`, the value of `i`, to the console.

The 'Until' Loop

Sometimes you do know how many times you'll be looping, however, and when that's the case, you'll want to use a `for` loop.

The 'For' Loop

The `next` keyword can be used to skip over certain steps in the loop. For instance, if we don't want to print out the even numbers, we can write:

```rb
for i in 1..5
  next if i % 2 == 0
  print i
end
```

1. In the above example, we loop through the range of 1 through 5, assigning each number to `i` in turn.
2. If the remainder of `i / 2` is zero, we go to the next iteration of the loop.
3. Then we print the value of `i`. This line only prints out `1`, `3`, and `5` because of the previous line.

Next!

Great work! You're really getting the hang of this.

The `loop` iterator is the simplest, but also one of the least powerful. A more useful iterator is the `.each` method, which can apply an expression to each element of an object, one at a time. The syntax looks like this:
```rb
object.each { |item| 
  # Do something 
}
```
You can also use the `do` keyword instead of `{}`:
```rb
object.each do |item| 
  # Do something 
end
```
The variable name between `| |` can be anything you like: it's just a placeholder for each element of the object you're using `.each` on.

The .each Iterator

Cool, no? Now it's your turn to take the `.each` method for a test drive.

```rb
numbers = [1, 2, 3, 4, 5]

# one way to loop
numbers.each { |item| puts item }

# another way to loop
numbers.each do |item|
  puts item
end
```

1. In the example above, we create an array called `numbers`. 
2. Then we show two different ways to print each item in `numbers` to the console.