Learn how to create loops that will make repetitive tasks easier and faster!

Loops

```swift
for _ in 1...10 {
  print("Great job!")
}
print("Now time to review loops!")
```

The above syntax should now look familiar!

In this lesson, we went over:
* Manually repeating tasks.
* `for-in` loops are used to iterate over collection items like ranges and strings.
* `stride()` creates a range that we can customize.
* `_` usage when we don't need to use the placeholder variable.
* `continue` allows us to move on to the next value.
* `break` stops the loop before the stopping condition is met. 
* `while` loops are used when we don't know how many times we're looping.

Review

When iterating through a sequence, we might not need to use every single value. In these cases, it'd be nice to just tell our loop to skip a value. That's where `continue` comes in.

If we wanted to only print out all the characters except for vowels (`"a"`, `"e"`, `"i"`, `"o"`, `"u"`) in a `String`:

```swift
let challenge = "bring it"

for char in challenge {
  switch char {
    case "a", "e", "i", "o", "u":
      continue
    default:
      print(char)
  }
}
```  

In the example above, we have a `switch` statement which checks `char` and if it is any of the following characters: `"a"`, `"e"`, `"i"`, `"o"`, and `"u"`. Inside our `case` statement, if the character matches, we skip over it with `continue`. If our character is not a vowel, then we print it out. 

When we run our code, it prints out:

```
b
r
n
g

t
```

The continue Keyword

Another loop we can use is the `while` loop. This loop allows us to continue iterating for as long as a condition remains `true`. 

```pseudo
while condition {
  // Execute while condition remains true
}
```

`while` loops really shine for situations when we're not exactly sure how long we need to loop for. For instance, let's say we have a simple dice game that keeps a total of the numbers we've rolled. The goal of this game is to keep rolling until our total is at least 50. We know we'll reach 50 eventually but we don't know how many rolls we need to reach our stop condition. Coding it up, we get:

```swift
var total = 0

while total < 50 {
  let diceRoll = Int.random(in: 1...6)
  total += diceRoll
}
```

Now let's break down what's going on:
* The `while` keyword starts our loop and accepts a condition: `total < 50`.
* Just like the `for`-`in` loop, after the condition is the body enclosed by a set of curly braces `{ }`. The body's code is executed during each iteration of the loop. 
* In the body, we declare `let diceRoll` with a value of `Int.random(in: 1...6)`. In each iteration of the loop, we're declaring a new `diceRoll` that has a random number from `1` to `6`. 
* In addition to reassigning `diceRoll`, we're also adding `diceRoll` to `total`. Eventually, `total` will be at least `50` and the loop _terminates_ (ends).
* It's important to note that we're increasing `total` because it's related to our stopping condition. If we forgot to, our `while` would continue to run without any instructions to stop. This non-terminating loop is known as an _infinite loop_. It'll continue to run and take up our computer's resources until we manually force it to close. Therefore, remember to add a way for your loop to end.


While Loop

Aside from sequences of numbers, we can also loop over `String`s! After all, a string is a collection of characters. 

Let's say we wanted to look over a string and see if it contains `"z"`. In a program, that means we would loop through the characters of a `String`. In each iteration would we check if the character was a `"z"`. 

```swift
var quote = "our whole life is solving puzzles."

for character in quote {
  print(character)
  if character == "z" {
    print("There's a z!")
  }
}
```

The basic structure of the `for`-`in` loop remains the same, but now we're going through each character of our `String`, instead of each number of a range. 

The example above would print out: 

```bash
o
u
r

w
h
...
z
There's a z!
z
There's a z!
l
e
s 
.
```

In our print out, we see that each character of the `String` is printed out (we skipped over a few characters with a `...` to lessen the amount printed). Additionally, each time `character` is a `"z"` we also print out `There's a z!`. 



Iterating Through Strings

Let's say we need to find out what "respect" means in the dictionary. We would iterate through the pages of the dictionary until we found the word "respect" and read the definition. Although we had planned on going through the dictionary, we could _break_ out of the loop after finding "respect". 

This same idea can be applied for loops as well. We can use the `break` keyword to exit out of the loop before the loop fully completes:

```swift
let respect = 556

for pageNum in 1...1000 {
  if pageNum == respect {
    print("Respect means: to admire someone for their abilities.")
    break
  }
  print("On page \(pageNum) and still no 'respect'!")
}
```

Prints out: 

```bash
On page 1 and still no 'respect'!
On page 2 and still no 'respect'!
...
On page 555 and still no 'respect'!
Respect means: to admire someone for their abilities.
```

In our loop, we plan to iterate from `1` to `1000` but after finding the correct `pageNum` that defines "respect", we `break` out of our loop. Notice, the `break` keyword will terminate the loop &mdash; we didn't continue to print out `"On page \(pageNum) and still no 'respect'!"`. 


The break Keyword

Now that we can appreciate what loops do for us, let's start with the `for`-`in` loop. Below is the general syntax: 

```pseudo
for placeholderVariable in someSequence {
  for-in loop body
}
```

We use [`for`-`in`](https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID121) loops to iterate over a sequence of values, such as `String`s (which is a sequence of characters) or _ranges_ (sequence of numbers). To create a range, we use the closed range operator (`...`) with a lower bound number and an upper bound number. For example, a range of `1...3` that has a lower bound of `1` and an upper bound of `3` contains the numbers: `1`, `2`, and `3`. 

Let's say we wanted to use a `for`-`in` loop to iterate (repeat tasks) while going through the sequence of numbers `7`, `8`, and `9` represented by the range: `7...9`.  

```swift
print("Why is 6 afraid of 7? Because …")
for num in 7...9 {
  print(num)
}
```

Now let's break down the example above:
* The `for` keyword starts the loop.
* `num` is a variable that holds the value of the current iteration. Notice that we don't use a keyword like `var` to declare it &mdash; the Swift compiler does this for us. We can think of it as a placeholder, i.e. during the first iteration, the placeholder (`num`) has a value of `7`.
* The `in` keyword separates the placeholder from the sequence used for iteration.
* `7...9` is a range containing the numbers `7`, `8`, and `9` and is the sequence we're iterating over. 
* The `for`-`in` loop has a _body_ enveloped by curly braces `{ }`. The code inside the body gets executed for each iteration. 

After taking the syntax into consideration, it would make sense that our code snippet prints out:

```bash
Why is 6 afraid of 7? Because …
7
8
9
```

Get it? 7 8 9! Cause 8 sounds like "ate"? So 7 "ate" 9!? ... Alright, back to programming... 😅

The for-in Loop

Remember our ["Smelly code" chalkboard](https://content.codecademy.com/courses/learn-swift/loops/ChalkboardLoop.svg)? Smelly code, or often referred to as having a _code smell_ refers to bad programming practices that make it hard for [developers to work on their code](https://xkcd.com/1513/). So it would be an appropriate punishment to make someone write, "I will not write smelly code" over and over again on a chalkboard.

Our goal, however, is to make this task easier using the power of loops, like so:

```swift
for num in 1...10 {
  print("I will not write smelly code.")
}
```

But notice, we don't actually use `num` in our loop body. Swift's compiler actually gives us a _warning_ which contains a message informing the developer of a potential issue or a suggested improvement: 

```error
immutable value 'num' was never used; consider replacing with '_' or removing it
```

We've seen these errors before when we wrote our loop but didn't add any code inside its body. Therefore, to avoid the warning (i.e. code smell), it's good practice to replace `num` with an underscore `_`: 

```swift
for _ in 1...10 {
  print("I will not write smelly code.")
}
```

In the example above, we don't have to worry about the placeholder; we're still able to print out `"I will not write smelly code."` ten times, and we don't get a warning! 


Using Underscore

Every day, we repeat a lot of things and we might not even think about it. For instance, when we cook, we might have to prepare our ingredients by chopping them up. We chop and chop and chop until all of our ingredients are the right sizes. At this point, we stop chopping. We can break down our chopping task into three smaller parts:
* Start condition: We're ready to cook.
* Repetition: We're chopping away.
* End condition: We have no more ingredients to chop. 

In programming, this entire process with a starting condition, repetition, and ending condition is called a _loop_. In a loop, we _iterate_ (perform repeating tasks) using a collection of items. In the example above, our collection would be our ingredients and the iteration happens when we're chopping up our ingredients.  

Some collections might be small &mdash; like a short string, other collections might be massive like a range of numbers from 1 to 10000000! But worry not, loops give us the ability to masterfully handle both ends of the spectrum. This simple, but powerful, concept saves us a lot of time and makes it easier for us to work with large amounts of data. 

In this lesson, we'll learn about Swift's different types of loops and how to use them in our programs.

    


Chalkboard of filled with from top to bottom with the sentence "I will not write smelly code" with a visibly annoyed person standing next to it. 

What are Loops?

Before we get to writing our own loops, let's explore what programming would be like if we couldn't use loops.  

Let's say we want to make a program that prints `"Hip Hip Hooray!"` 5 times:

```swift
print("Hip Hip Hooray!")
print("Hip Hip Hooray!")
print("Hip Hip Hooray!")
print("Hip Hip Hooray!")
print("Hip Hip Hooray!")
```

That's still manageable, we're writing 5 `print()` statements (or copying and pasting a few times). But, imagine if we come back to this program and we want to change it to print `"Hip Hip Hooray!"` 10, or 24601, or … 100000000 times? It would take an extremely long time and by the end, we could still end up with inconsistencies and mistakes. 

Don't dwell too long on this tedious scenario &mdash; we'll learn how loops can help us out in the next exercise. For now, let's gain an appreciation for loops. 😈


Repeating Tasks

`for`-`in` loops also give us the flexibility to choose how we want to iterate over a sequence with the `stride()` function:

```pseudo
stride(from: a, to: b, by: c)
```

Notice, in order to use the `stride()` function we have to supply 3 values separated by commas. When we use it in a `for`-`in` loop:

```swift
for num in stride(from: 0, to: 6, by: 2) {
  print(num)
}
```

It prints out:

```bash
0
2
4
```

The values we provide functions are called [_arguments_](https://docs.swift.org/swift-book/LanguageGuide/Functions.html#ID159). In each argument there is an [_argument label_](https://docs.swift.org/swift-book/LanguageGuide/Functions.html#ID166), e.g. `from:`, `to:`, `by:`. We'll cover more about how functions work in a later lesson, but here's a sneak peek:
* The first argument, `from: 0` is the starting number of the sequence (`0`). 
* The second argument, `to: 6` is the end of the sequence (`6`). But notice, we didn't print out `6` which means this end number is not included.
* The third argument, `by: 2` determines how much to increment (or decrement if we use a negative number) during each iteration. Here's how the value of `num` changes in the loop:

| iteration # | `num` Value | 
| ------------- |-------------|
| first | `0` |
| second | `2` | 
| third | `4`|


