Practice loops to easily repeat blocks of code using the Go programming language!

Loops

Maps and arrays are some of the most fundamental data structures. Reading and modifying their contents will be done often in any codebase.

Luckily, their properties grant them an easy-to-use syntax for looping through their elements. A programmer can use a tiny amount of code to manage large collections of data!

Each map and array has a set amount of items that they contain. In Go, the `range` keyword can be used to work through these items one at a time within a loop. For example:

```go
letters := []string{"A", "B", "C", "D"}
for index, value := range letters {
  fmt.Println("Index:", index, "Value:", value)
}
```

Would output the following:

```text
Index: 0 Value: A
Index: 1 Value: B
Index: 2 Value: C
Index: 3 Value: D
```

The `range` keyword is used here similarly to the initial statement of a definite loop. It lets the programmer assign two new variables for the index and value of each item in the array.

The behavior is the same for maps. But as they don't have an index, `range` provides the key and value pairs for each item instead.

For example:

```go
addressBook := map[string]string{
  "John": "12 Main St",
  "Janet": "56 Pleasant St",
  "Jordan": "88 Liberty Ln",
}
for key, value := range addressBook {
  fmt.Println("Name:", key, "Address:", value)
}
```

Which would output the following:

```text
Name: John Address: 12 Main St
Name: Janet Address: 56 Pleasant St
Name: Jordan Address: 88 Liberty Ln
```

Now you can use loops for maps and arrays in Go!

Work through the following checkpoints to finish up the lesson!


Looping and Arrays

An `if` statement allows us to check a specific condition once. But what if that condition needs to be checked a certain number of times?

**Definite loops** can be used to repeat code a fixed number of times.

While an `if` statement only has a conditional expression (like `number < 5`), a definite loop has two additional components:
- An **initial statement**, which defines the starting value for a loop variable.
  <br>  Ex: `number := 0`
- A **post statement**, which defines what happens at the end of each loop iteration.
  <br>  Ex: `number++`

So while an `if` statement that prints one number less than `5` may look like this:

```go
number := 3
if number < 5 {
  fmt.Println(number)
}
// Output: 3
```

A `for` loop that prints the numbers `0`, `1`, `2`, `3`, and `4` would look like this:

```go
for number := 0; number < 5; number++ {
  fmt.Print(number, " ")
}
// Output: 0 1 2 3 4
```

While the `if` statement prints a number once, the `for` loop uses a similar syntax to print a number five times.

Let's dive deeper into each component of that definite loop:

- The initial statement, `number := 0`, creates a new variable to be used within the `for` loop code block.

- The conditional expression, `number < 5`, will stop the loop when `number` reaches the target value of `5`.

- The post statement, `number++`, increases the value of the `number` variable by `1` each time the code block completes.

In this example, the amount of times that the `number` needed to be printed was known beforehand. But what do we do when we don't know how many times a loop needs to run?

Find out more in the next exercise!

The Classic For Loop

This GIF repeats a loop of turning a rectangle over and over again.

A **loop** is a way of repeating a block of code until a certain condition is met.

Loops build on top of the logic found in conditional `if` statements. When an `if` statement's condition is true, its code block is executed once. In a `for` loop, the code block is *repeated* until the condition is no longer true.

Haven’t found everything you need in a grocery store yet? Then while that condition is true, the following steps need to be completed over and over again:

- Read an item off of the shopping list.
- Find that item in the store.
- Put that item in the cart.

A robot could follow this loop to shop in a store for us! And just as repetitive tasks like these are common in real life, they are also common in programming.

Keep going to see how programmers repeat tasks using loops!

Introduction to Looping

Sometimes it is impossible to know how many iterations of a loop are needed ahead of time.

For example, imagine if a club is throwing an event to promote new member sign-ups. The club has to process each new sign-up as long as more people keep coming!

In situations like these, indefinite loops can be used. **Indefinite loops** are loops that repeat while a condition remains true. So with the club example, an indefinite loop could run as long as there are new sign-ups to process.

Some other examples could be:
- A car that accelerates while the gas is being pressed.
- A stove that heats up while the knob is turned on.
- A music player that plays songs while the pause button is **not** pressed.

All of these examples show some sort of process happening **while** a condition is met. Most programming languages use the `while` keyword to declare indefinite loops.

However, the behavior of definite and indefinite loops is very similar. For this reason, Go simplifies the language by using only the `for` keyword for both types of loops.

The syntax between the two types of loops is pretty similar, but with some crucial differences.

First, any variables to be used inside the loop need to be initialized ahead of time. Second, any update to these variables has to be manually included within the code block. So the previous printing numbers example using a definite loop:

```go
for number := 0; number < 5; number++ {
  fmt.Println(number)
}
```

Can be rewritten like so as an indefinite loop:

```go
number := 0 // Initialize a variable to be used inside the loop
for number < 5 {
  fmt.Println(number)
  number++ // Update the variable being used
}
```

Both of these code snippets produce the same output, they are just different ways of implementing the same logic.

What would happen if the previous code didn't contain `number++`? Find out in the next exercise!

For as a While Loop

Congratulations! You have made it through the lesson!

Loops are a staple in any programmer's toolbox for automating repetitive tasks.

Similar to an `if` statement, a **loop** repeats a block of code while a certain condition is met.

When these loops repeat a fixed number of times, it is called a **definite loop**. A definite loop can be programmed like so:

```go
for number := 0; number < 5; number++ {
 fmt.Println(number)
}
```

Sometimes the number of iterations cannot be known ahead of time. For moments like this, an **indefinite loop** can be used that repeats as long as a condition remains true. Indefinite loops usually look like this:

```go
number := 0
for number < 5 {
  fmt.Println(number)
  number++
}
```

But sometimes indefinite loops can become **infinite loops** if they never end. An infinite loop can be a problem if the user believes that the program has frozen. On the other hand, an infinite loop can be useful when a web server needs to be constantly running.

To stop a loop on demand, a `break` statement can be used. If the current iteration of the loop needs to be skipped instead, there is also a `continue` statement:

```go
for count := 0; count < 20; count++ {
  if count == 8 {
    continue
  }
  if count == 15 {
    break
  }
  fmt.Println(count)
}
```

The `range` statement gives a simple syntax for iterating maps and arrays:

```go
letters := []string{"A", "B", "C", "D"}
for index, value := range letters {
  fmt.Println("Index:", index, "Value:", value)
}
```

In your next program, use loops to automate your most repetitive tasks!

Review

Sometimes an indefinite loop does not end, creating an infinite loop.

An **infinite loop** is a loop where the condition can never be reached, causing the loop to run forever.

Sometimes this can be dangerous as it can make a program appear to be frozen to the user. But for something like a web server that constantly needs to be running, these infinite loops are critical.

While an infinite loop can be any loop that does not end, a purposefully created infinite loop is written like this:

```go
for {
  // Loop body logic
  // This repeats forever
}
// This is never reached
```

There is also a way to stop these loops at a certain point in code, which will be discussed in the next exercise!


Infinite Loops

How does a programmer get more direct control over a loop? With the `break` and `continue` keywords!

The `break` keyword allows the programmer to stop the loop at the current iteration.

For example, if using a loop to search for a specific pet, the loop can be made to `break` and stop when that animal has been found:

```go
animals := []string{"Cat", "Dog", "Fish", "Turtle"}
for index := 0; index < len(animals); index++ {
  if animals[index] == "Dog" {
    fmt.Println("Found the perfect animal!")
    break // Stop searching the array
  }
}
```

The `continue` keyword works similarly, allowing the loop to skip to the next iteration.

For example, there may be an array filled with jellybeans. To not eat the disgusting green jellybeans, a `continue` statement can be used to skip them:

```go
jellybeans := []string{"green", "blue", "yellow", "red", "green", "yellow", "red"}
for index := 0; index < len(jellybeans); index++ {
  if jellybeans[index] == "green" {
    continue
  }
  fmt.Println("You ate the", jellybeans[index], "jellybean!")
}
```

However, using `continue` and `break` statements tend to cause confusion over how a loop will behave. A `break` statement changes when a loop will end. While a `continue` statement changes what will happen in each loop.

While these keywords may not always be the best choice, they work really well for the use case covered in the next exercise, iterating through arrays and maps!
