ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn how to create code repetition using loops in Kotlin!

Loops

Unlike a list or a set, a map is a collection of entries. When using a map as a `for` loop iterator, we can iterate through each entry of the map or through just the keys, or just the values.
 
When iterating through a map, the loop variable will hold one entry per iteration. The entry's key and value can be accessed using the properties, `key` and `value`:
```kt
val myClothes = mapOf("Shirts" to 7, "Pairs of Pants" to 4, "Jackets" to 2)
 
for (itemEntry in myClothes) {
  println("I have ${itemEntry.value} ${itemEntry.key}")
}
```
Notice that in order to access the attributes in a String template, we surround the loop variable and the attribute in curly brackets. 

We can also access the `key` and `value` of each entry by destructuring using two loop variables in parentheses. The first variable is the entry's `key` and the second is the `value`:
```kt
val myClothes = mapOf("Shirts" to 7, "Pairs of Pants" to 4, "Jackets" to 2)
 
for ((itemName, itemCount) in myClothes) {
  println("I have $itemCount $itemName")
}
```
Both examples have the same output: 
```
I have 7 Shirts
I have 4 Pairs of Pants
I have 2 Jackets
```
Lastly, we can iterate through just a map's keys or values. A map has the properties `keys` and `values` which can each be used as an iterator:
```kt
val myClothes = mapOf("Shirts" to 7, "Pairs of Pants" to 4, "Jackets" to 2)
 
println("KEYS")
for (itemName in myClothes.keys) {
  println(itemName)
}
 
println("\nVALUES")
for (itemCount in myClothes.values) {
  println(itemCount)
}
```
Here is the output:
```
KEYS
Shirts
Pairs of Pants
Jackets

VALUES
7
4
2
```

Iterating Through Maps 

Why write 100 lines of code when you can write 2? When we come across code we want to repeat, we can rely on *loops*. Loops give us the ability to repeat specified blocks of code as many times as we want.

Let’s say we wanted to output elements in a list. The process wouldn’t be that bad if the list had 5 elements. We could write five `println()` statements. What if the list had 100 elements? Or 1,000? Or even 100,000?!

Loops answer the call when we need to repeat a task over and over again, even if it is millions of times.
 
In this lesson, we will look at loops that will repeat code a defined number of times or based on a specific condition. We will look at how to combine loops to obtain a higher number of repetitions as well as how to exit loops early or skip code repetitions.
 
By the end of this lesson you will understand the best way to repeat tasks in a controlled manner while keeping your code organized and readable.

Codey is hiking through the Land of Loops. Throughout the afternoon, Codey is repeating his steps while the time is less than 18.

Introduction to Loops

The jump expressions, `break` and `continue`, are used to change the standard loop behavior by exiting a loop early or skipping a single repetition.
 
The `break` expression is used to exit the loop at a particular iteration:
```kt
val myNumbers = listOf(4, 8, 2, 9, 12, 7, 16, 10, 3)
for (num in myNumbers) {
  if (num > 9) {
    break
  }
  println(num)
}
```
In this example: 
- the `for` loop iterates through the list of Ints.
- each iteration the current number, `num`, is tested to see if it is greater than 9.  
- if `false`, the number is output.
- if `true`, the `break` expression exits the loop. 

We can see the below output stops before printing the number `12`:
```
Output
4
8
2
9
```
The `continue` expression will skip the current execution of the loop body, but the loop will keep going if there are iterations left. If the `continue` expression gets executed, any code left in the current iteration will be skipped:
```kt
val myNumbers = listOf(4, 8, 2, 9, 12, 7, 16, 10, 3)
for (num in myNumbers) {
  if (num > 9) {
    continue
  }
  println(num)
}
```
This example is the same as the last but we replaced the `break` with `continue`. The below output skips all values of `num` greater than `9`, while printing out the rest of `numbers`: 
``` 
Output
4
8
2
9
7
3
```
The first example outputs the elements in `myNumbers` **until** you reach one greater than `9`. The second example outputs **all** elements in `myNumbers` **except** those that are greater than `9`. 

Since jump expression are usually contained inside `if` expressions, they gives us the ability to add a condition to exit a `for` loop or using another condition to exit a `while` loop.

Don't worry if this all doesn't stick right away; keep practicing with each jump expression and you'll quickly get the hang of how and when each one is used. 

Jump Expressions

When we know how many times we want a section of code to repeat, we often use a *for loop*.
 
A `for` loop starts with the `for` keyword and is followed by a statement that defines a loop variable followed by identifying an *iterator*: 
```kt
for(i in 1..4) {
  println("I am in a loop!")
} 
```
- `for` is a keyword used to declare a `for` loop.
- We define `i` as the loop variable. This variable holds the current iteration value and can be used within the loop body.
- The `in` keyword is between the variable definition and the iterator.
- The range `1..4` is the `for` loop iterator.

An [iterator](https://kotlinlang.org/docs/reference/iterators.html) is an object that allows us to step through and access every individual element in a collection of values. In most cases, the iterators we use in `for` loops are ranges and collections. In this example, the range has 4 elements so the `for` loop repeats `4` times: 
```
I am in a loop!
I am in a loop!
I am in a loop!
I am in a loop!
```
It is important to note that the loop variable only exists within the loop's code block. Trying to access the loop variable outside the `for` loop will result in an error. 

Here is an example of using the loop variable within the loop body:
```kt
for (i in 1..4) {
  println("i = $i")
}
```
While the above example uses literal numbers `1..4` to define the range, we can also use variables to define the boundaries of our loop's range, giving us more dynamic control over our loop's iteration:

```kt
var num = 4
for (i in 1..num) {
  println("i = $i")
}
```
Both of the code snippets produce the same final output:
```
i = 1
i = 2
i = 3
i = 4
```

for Loop

"How would we use jump expressions inside nested loops?" Good question! The answer is *labeled jump expressions*. By adding a label to the outer loop of nested loops, we can execute a jump expression from the inner loop and have it act on the labeled outer loop. 

First we need to give a name to our label. In the following example we choose the name `rps`. The outer loop is marked using our label `rps` followed by the `@` symbol:
```kt
val game = listOf("Rock", "Paper", "Scissor")

rps@ for (p1 in game) {
  for (p2 in game) {
    if (p1 == "Paper") {
      break@rps
    }
    println("$p1 vs. $p2")
  }
}
```
The inner loop has an `if` expression that contains a `break` expression with `@rps` appended. When the condition, `p1 == "Paper"` is `true`, `break@rps` executes and exits the outer loop:
```
Rock vs. Rock
Rock vs. Paper
Rock vs. Scissor
```
Now let’s look at what happens in our example when we change the `break` expression to a `continue`:
```kt
val game = listOf("Rock", "Paper", "Scissor")

rps@ for (p1 in game) {
  for (p2 in game) {
    if (p1 == "Paper") {
      continue@rps
    }
    println("$p1 vs. $p2")
  }
}
```
What we see now is the outer loop skips an iteration when `p1 == "Paper"` but resumes with the final iteration when `p1` is equal to "Scissor":
```
Rock vs. Rock
Rock vs. Paper
Rock vs. Scissor
Scissor vs. Rock
Scissor vs. Paper
Scissor vs. Scissor
```
Labeled jump expressions give us more control over nested loops to help us achieve the desired behavior from our code. Using them can be tricky, but once understood they can be very powerful.

Labeled Jump Expressions

When repeating code we may not have a range or defined collection to dictate the number of loops we need to execute. In this case, we can rely on a  *while loop* which repeats code as long as a specified condition is `true`. If we revisit the animation in the first exercise, we can see that Codey uses a `while` loop to hike until `time` is no longer less than 17.
 
A `while` loop is similar to an `if` expression because it tests a condition and when the condition is `true` a body of code is executed. The main difference is the `while` loop will complete the body of code, check the condition, and repeat the code if the condition is still `true`. If the condition is `false`, the while loop is done and the program moves on:
```kt
var myAge = 16

while (myAge < 20) {
  println("I am a teenager.")
  myAge += 1
}
println ("I am not a teenager.")
```
In this example the while loop condition `myAge < 20` initially evaluates to `true`. The loop body is executed which outputs some text and `myAge` is incremented. The loop repeats until `myAge` equals 20 at which point the loop exits and continues running code outside the loop:
``` 
I am a teenager. // myAge is 16
I am a teenager. // myAge is 17
I am a teenager. // myAge is 18
I am a teenager. // myAge is 19
I am not a teenager. // myAge is 20
``` 
If `myAge` wasn't incremented inside the loop body the loop condition would always be `true` and repeat forever. This is known as an *infinite loop*. Infinite loops lead to application crashes or other unwanted behavior so it is important that they are avoided.
 
When a `while` loop condition never evaluates to `true`, the entire block of code is skipped:
```kt
var myAge = 44

while (myAge > 12 && myAge < 20) {
  println("I am a teenager.")
  myAge += 1
}
println ("I am not a teenager.")
```
Since we've set the value of `myAge` to `44` and the condition will only be `true` once the value is between `12 ` and `20`,  the code block is skipped and the final `println()` gets executed:
```
I am not a teenager.
```

while Loop

A `do`..`while` loop is just like a `while` loop except the looping condition is checked at the end of the loop body. This is known as an exit-condition loop and means the code in the body will execute at least once: 
```kt
val myCondition = false

do {
  print("I loop once!")
} while(myCondition)
```
This example shows that even though we have a `false` condition our loop will still run the loop body once:
```
I loop once!!!!
```
One reason we would use a `do`..`while` loop is when our loop condition initialization and update commands are the same. Using psuedocode we can compare a `while` loop with a `do`..`while` loop using how someone might decide to go outside:
```pseudo 
Is it sunny outside?
while ( not sunny ) {
  Is it sunny outside?
  Stay inside.
}
Go outside!
``` 
The `while` loop example has a line before the loop to check if it is sunny outside. The loop is entered if it is not sunny and then repeatedly checks if it is sunny outside. When it is sunny, the loop exits and it’s time to go outside:
```pseudo
do {
  Is it sunny outside?
  Stay inside.
} while ( not sunny )
Go outside!
```
The `do`..`while` loop enters the loop and starts by checking if isSunny is `true`. The loop body repeats if the isSunny is `false`. 

The extra check prior to the loop is unnecessary since it is performed inside the loop anyway. If we have to look outside to get our initial loop condition **and** to update our loop condition, we might as well have that be the loop body and check the condition at the end.
 
This difference may seem subtle, but if this loop is executed hundreds or thousands of times a second, removing the one line of code using a `do`..`while` loop may save time.

do..while Loop

Loops inside loops, oh my! A nested loop represents one loop placed inside the body of another loop which results in a higher dimensions of iterations. This strategy is most often used when we'd like to compare the contents of two different collections/iterators. 

Below is an example of nested loops. The outer loop iterates through the range `1..2` and the inner loop iterates through the range `'A'..'C'`:
```kt
for (i in 1..2) {
  for (j in 'A'..'C') {
    println("Outer loop: $i - Inner loop: $j")
  }
}
```
It's important to understand that for every iteration in the outer loop, the inner loop will run through all of its own iterations. 

In the example above, the inner loop iterates 3 times for each of the outer loop's 2 iterations. Therefore, the `println()` statement is run 6 times:
```
Outer loop: 1 - Inner loop: A
Outer loop: 1 - Inner loop: B
Outer loop: 1 - Inner loop: C
Outer loop: 2 - Inner loop: A
Outer loop: 2 - Inner loop: B
Outer loop: 2 - Inner loop: C
```
When beginning with nested loops they may seem difficult to work with, but they make advanced applications easy to implement.

Nested Loops

Instead of using a range, we can use the structure of a collection as an iterator. A `for` loop will iterate through each of the collection's elements with the loop variable holding the value of the current element. We will focus on lists and sets in this exercise and maps in the next one.

```kt
val fruitList = listOf("apples", "oranges", "bananas")
 
for (fruit in fruitList) {
  println("I have $fruit.")
}
```
In this example, we declare `fruit` as the loop variable and use `fruitList` as the iterator. Each iteration of the loop will set `fruit` to the value of the current element of `fruitList`. Therefore, the number of elements contained in `fruitList` determines the number of times `println("I have $fruit.")` is executed:
```
I have apples.
I have oranges.
I have bananas.
```
When we first learned about lists and sets in the collections lesson, we discussed their commonality as well as their differences. An additional similarity is that the syntax for iterating through a list and a set is the same.
 
When iterating through a collection, it is often useful to know what element number, or iteration, we are at. To iterate through the indices of a collection you can use its `indices` property:
```kt
val fruitSet = setOf("apples", "oranges", "bananas")
 
for (setIndex in fruitSet.indices) {
  println("Index = $setIndex")
}
```
Here we see the indices of `fruitSet` output. Remember that the first index of a list or a set is always `0`:
```
Index = 0
Index = 1
Index = 2
```
We can also get the index AND the iterator element using the collection’s `withIndex()` function. In this case we need to [destructure](https://kotlinlang.org/docs/reference/multi-declarations.html) the loop variable declaration by declaring two loop variables and enclosing them in parentheses:

```kt
val fruitList = listOf("apples", "oranges", "bananas")
 
for ((listIndex, fruit) in fruitList.withIndex()) {
  println("$listIndex is the index of the element $fruit")
}
```
Using `withIndex()` and destructuring, we are able to access both the index and the element of `fruitList`:
```
0 is the index of the element apples
1 is the index of the element oranges
2 is the index of the element bananas
```

Iterating Through Collections

Sometimes we want to count backwards, or count by 2s, or both! Using certain functions alongside or instead of the normal range operator (`..`) can enhance the iterative abilities of our `for` loops. The functions `downTo`, `until` and `step` give us more control of a range and therefore more control of our loops.
 
The `downTo` function simply creates a reverse order group of values, where the starting boundary is greater than the ending boundary. To accomplish this, replace the range operator (`..`) with `downTo`:
```kt
for (i in 4 downTo 1) {
  println("i = $i")
}
```
We can see in the output that the first number in `i` is `4` and the last is `1`:
```
i = 4
i = 3
i = 2
i = 1
```

The `until` function creates an ascending range, just like the (`..`) operator, but excludes the upper boundary:
```kt
for (i in 1 until 4) {
  println("i = $i")
}
```
The upper boundary, `4`, is not included in the output:
```
i = 1
i = 2
i = 3
```
Up until now, each of these functions, including the range operator (`..`), have counted up or down by one. The `step` function specifies the amount these functions count by:
```kt
for (i in 1..8 step 2) {
  println("i = $i")
}
```
The loop variable `i` now increases by 2 for every iteration. The last number output is `7`, since 2 steps up from that is `9` which is outside the defined range, `1..8`:
```
i = 1
i = 3
i = 5
i = 7
```