|
| 1 | +# About |
| 2 | + |
| 3 | +## General syntax |
| 4 | + |
| 5 | +The for loop is one of the most commonly used statements to repeatedly execute some logic. In Go it consists of the `for` keyword, a header and a code block that contains the body of the loop wrapped in curly brackets. The header consists of 3 components separated by semicolons `;`: init, condition and post. |
| 6 | + |
| 7 | +```go |
| 8 | +for init; condition; post { |
| 9 | + // loop body - code that is executed repeatedly as long as the condition is true |
| 10 | +} |
| 11 | +``` |
| 12 | + |
| 13 | +- The **init** component is some code that runs only once before the loop starts. |
| 14 | +- The **condition** component must be some expression that evaluates to a boolean and controls when the loop should stop. The code inside the loop will run as long as this condition evaluates to true. As soon as this expression evaluates to false, no more iterations of the loop will run. |
| 15 | +- The **post** component is some code that will run at the end of each iteration. |
| 16 | + |
| 17 | +**Note:** Unlike other languages, there are no parentheses `()` surrounding the three components of the header. In fact, inserting such parenthesis is a compilation error. However, the braces `{ }` surrounding the loop body are always required. |
| 18 | + |
| 19 | +## For Loops - An example |
| 20 | + |
| 21 | +The init component usually sets up a counter variable, the condition checks whether the loop should be continued or stopped and the post component usually increments the counter at the end of each repetition. |
| 22 | + |
| 23 | +```go |
| 24 | +for i := 1; i < 10; i++ { |
| 25 | + fmt.Println(i) |
| 26 | +} |
| 27 | +``` |
| 28 | + |
| 29 | +This loop will print the numbers from `1` to `9` (including `9`). |
| 30 | +Defining the step is often done using an increment or decrement statement, as shown in the example above. |
| 31 | + |
| 32 | +## Optional components of the header |
| 33 | + |
| 34 | +The init and post components of the header are optional: |
| 35 | + |
| 36 | +```go |
| 37 | +var sum = 1 |
| 38 | +for sum < 1000 { |
| 39 | + sum += sum |
| 40 | +} |
| 41 | +fmt.Println(sum) |
| 42 | +// Output: 1024 |
| 43 | +``` |
| 44 | + |
| 45 | +By omitting the init and post component in a for loop like shown above, you create a while loop in Go. |
| 46 | +There is no `while` keyword. |
| 47 | +This is an example of Go's principle that concepts should be orthogonal. Since there is already a concept to achieve the behavior of a while loop, namely the for loop, `while` was not added as an additional concept. |
| 48 | + |
| 49 | +## Break and Continue |
| 50 | + |
| 51 | +Inside a loop body you can use the `break` keyword to stop the execution of the loop entirely: |
| 52 | + |
| 53 | +```go |
| 54 | +for n := 0; n <= 5; n++ { |
| 55 | + if n == 3 { |
| 56 | + break |
| 57 | + } |
| 58 | + fmt.Println(n) |
| 59 | +} |
| 60 | +// Output: |
| 61 | +// 0 |
| 62 | +// 1 |
| 63 | +// 2 |
| 64 | +``` |
| 65 | + |
| 66 | +In contrast, the keyword `continue` only stops the execution of the current iteration and continues with the next one: |
| 67 | + |
| 68 | +```go |
| 69 | +for n := 0; n <= 5; n++ { |
| 70 | + if n%2 == 0 { |
| 71 | + continue |
| 72 | + } |
| 73 | + fmt.Println(n) |
| 74 | +} |
| 75 | +// Output: |
| 76 | +// 1 |
| 77 | +// 3 |
| 78 | +// 5 |
| 79 | +``` |
| 80 | +## Infinite for loop |
| 81 | + |
| 82 | +The condition part of the loop header is also optional. In fact, you can write a loop with no header: |
| 83 | + |
| 84 | +```go |
| 85 | +for { |
| 86 | + // Endless loop... |
| 87 | +} |
| 88 | +``` |
| 89 | + |
| 90 | +This loop will only ever finish if the program exits or has a `break` in its body. |
| 91 | + |
| 92 | +## Labels and goto |
| 93 | + |
| 94 | +When we use `break`, Go will stop running the most inner loop. Similarly, when we use `continue`, Go will run the next iteration of the most inner loop. |
| 95 | + |
| 96 | +However, this is not always desirable. We can use labels together with `break` and `continue` to specifcy exactly from which loop we want to exit or continue, respectively. |
| 97 | + |
| 98 | +In this example we are creating a label `OuterLoop`, that will refer to the most outter loop. In the most inner loop, to say that we want exit from the most outter loop, we then use `break` followed by the name of the label of the most outter loop: |
| 99 | + |
| 100 | +```go |
| 101 | +OuterLoop: |
| 102 | + for i := 0; i < 10; i++ { |
| 103 | + for j := 0; j < 10; j++ { |
| 104 | + // ... |
| 105 | + break OuterLoop |
| 106 | + } |
| 107 | + } |
| 108 | +``` |
| 109 | + |
| 110 | +Using labels with `continue` would also work, in which case, Go would continue in the next iteration of the loop referenced by the label. |
| 111 | + |
| 112 | +Go also has a `goto` keyword that works in a similar way and allows us to jump to from a piece of code to another labeled piece of code. |
| 113 | + |
| 114 | +**Warning:** Even though Go allows to jump to a piece of code marked with a label, using this feature of the language can easily make the code very hard to read. For this reason, using labels is often not recommended. |
0 commit comments