Golang tutorial - 4 Control Flow (Iteration)
Tags: go, beginners, tutorial
Published: 2020-05-22 03:26:30

When creating a software or program, usually there are repetitive instructions or code to complete certain tasks. This repetitive or iterative instruction is called iteration or loop.  
## Iteration in Go
In Golang, there is only one type of iteration called for loop. The for loop can be customizable based on needs. The anatomy of for loop syntax in Go is like this :
`for (init condition; condition; post condition) { ... }`
There is for range loop that is suitable for iterating data in an array or slice.
`for index, value := range variable {...}`
## Iteration with for loop
The example of for loop usage can be seen in the code below. This code prints out the number from 1 to 10.
```go
package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
	}
}
```
The output:
```bash
1
2
3
4
5
6
7
8
9
10
```
Based on the code example above, the for loop consists of
* Initiation condition: `i := 1`  means start execution inside for loop from `i` equals `1`
* Condition: `i <= 10` means if `i` less than or equals 10, execute the post condition
* Post condition: `i++` means increase or add `i` value by 1.
* The code inside for loop which is `fmt.Println(i)` means print the value of `i` variable.

The for loop can be customized that give the same result, the customization of the for loop could be like this:
```go
package main

import "fmt"

func main() {
	i := 1
	for {
		fmt.Println(i)
		if i >= 10 {
			break
		}
		i++
	}

}
```
The output:
```bash
1
2
3
4
5
6
7
8
9
10
```
Notice in the code example above, that there is a `break` keyword. The `break` keyword means to stop or break the execution of code inside that for loop. There is a `continue` keyword as well which means resume or continue the execution. 

An example of `continue` keyword usage can be seen in this code:
```go
package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		if i%2 == 0 {
			continue
		}
		fmt.Println(i)
	}

}
```
The output: 
```bash
1
3
5
7
9
```
The result of the output prints the odd numbers, this happens because inside the for loop, there is condition selection if the value of the `i` variable has the remainder of 2 equals zero or if the value of `i` is an even number, then the `continue`  executed means continue to execute to the next loop so the value of `i` isn't printed out.

The usage of nested for loop is possible. The example of nested for loop usage can be seen in this code. This code prints out a stack of stars.
```go
package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ { //outer loop
		fmt.Println()
		for j := 0; j < i; j++ { //inner loop
			fmt.Print("*")
		}
	}
}
```
The output: 
```
*
**
***
****
```
From the example code above. The outer loop executes the code inside the outer loop and then continues to the inner loop until the execution of the code inside the outer loop is finished. 
## Iteration with for range
The iteration with for range is usually suitable for reading or iterating many data over an array or slice (slice in Go means the data structure that is similar to an array but has a more flexible size). The usage of for range can be seen in this code example.
```go
package main

import "fmt"

func main() {
	data := [5]int{1, 2, 3, 4, 5} //declares an array of int
	for i, v := range data {
		fmt.Println("index: ", i, "value: ", v)
	}

}
```
The output:
```
index:  0 value:  1
index:  1 value:  2
index:  2 value:  3
index:  3 value:  4
index:  4 value:  5
```
From the example code above, the structure of for range loop is like this :
* Variables: `i, v` means that retrieves index and value from an array called `data`. The naming conventions aren't restricted to `i` and `v`. It could be replaced with `idx` and `val` or other suitable variable names.
* `range` keyword: `:= range data` means the variable `data` is the target to retrieve the index or value.

The index can be ignored by using the `_` notation in Go. The example code can be seen below. This code calculates the average of numbers that are stored inside a slice called `data`.
```go
package main

import "fmt"

func main() {
	data := []int{1, 2, 3, 4, 5, 6, 7} //declares a slice of int
	sum := 0                           //declares sum variable
	for _, val := range data { //ignore index with _ notation
		sum += val
	}
	fmt.Println("The sum result is: ", sum)

}
```
The output:
```
The sum result is:  28
```
Based on the code example above, the value called `val` in this case is a value from the data variable. Each value is added to the sum variable.
## Notes
* These are the examples of operators that can be used in Go.

| Operator        |Equivalent Expression                                 |
| ----------------- |:--------------------------------------------------:| 
| `+=`                  | `var += 2` equals `var = var + 2`                | 
| `-=`                  | `var -= 2` equals `var = var - 2`                | 
| `*=`                  | `var *= 2` equals `var = var * 2`                | 
| `/=`                  | `var /= 2` equals `var = var / 2`                | 
| `%=`                  | `var %= 2` equals `var = var % 2`                | 
| `++`                  | `var++` equals `var = var + 1`                |
| `--`                  | `var--` equals `var = var - 1`                |  

Other available operators can be seen [here](https://go.dev/ref/spec#Operators_and_punctuation)

* The combination of `for` and `for range` is possible. The example is like this:
```go
package main

import "fmt"

func main() {
	data := [][]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}

	for _, v := range data {
		fmt.Println("Data: ", v)
		for i := 0; i < len(v); i++ {
			fmt.Println("\tDivided by 2:", v[i]/2)
		}
	}

}
```
Output:
```
Data:  [1 2 3]
        Divided by 2: 0
        Divided by 2: 1
        Divided by 2: 1
Data:  [4 5 6]
        Divided by 2: 2
        Divided by 2: 2
        Divided by 2: 3
Data:  [7 8 9]
        Divided by 2: 3
        Divided by 2: 4
        Divided by 2: 4
```
I hope this article helps to learn the Go programming language. If you have any thoughts or feedback, you can write it in the discussion section below.