106 lines
2.4 KiB
Markdown
106 lines
2.4 KiB
Markdown
---
|
|
title: Loops
|
|
---
|
|
|
|
# For loop in Go
|
|
Go has only `for` loop. The basic `for` loop has three components separated by `;` -
|
|
|
|
* the **init** statement: executed before the first iteration
|
|
|
|
* the **condition** expression: evaluated before every iteration
|
|
|
|
* the **post** statement: executed at the end of every iteration
|
|
|
|
The **init** statement is often a short variable declaration. The variables declared there are visible only in the scope of the `for` statement. The loop stops iterating once the boolean condition evaluates to false.
|
|
|
|
An example of the `for` loop is given below -
|
|
|
|
**for.go**
|
|
|
|
```go
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
func main() {
|
|
sum := 0
|
|
for i := 0; i <= 10; i++ {
|
|
sum += i
|
|
}
|
|
fmt.Println("The sum of first 10 natural numbers is", sum)
|
|
}
|
|
|
|
```
|
|
Running the above program produces an output similar to the following output -
|
|
```
|
|
$ go run for.go
|
|
The sum of first 10 natural numbers is 55
|
|
```
|
|
|
|
You can use `continue` and `break` to adjust the loops flow
|
|
```go
|
|
// this code prints any odd numbers up to 5
|
|
for n := 0; n <= 10; n++ {
|
|
if n % 2 == 0 {
|
|
// if the number is even jump to the next n
|
|
continue
|
|
}
|
|
fmt.Println(n)
|
|
// if the number is 5 exit the loop
|
|
if n == 5 {
|
|
break
|
|
}
|
|
}
|
|
```
|
|
If you want to create an infinite loop just use `for { }`
|
|
```go
|
|
for {
|
|
// Whill loop until a condition breaks the loop
|
|
break // exit the loop
|
|
}
|
|
```
|
|
|
|
## Replacement for while-loop
|
|
To simulate while-loop of other languages, you can simply exclude the **init** and **post** statement:
|
|
|
|
```go
|
|
func main() {
|
|
num := 1
|
|
for num <= 1000 {
|
|
num *= 2
|
|
}
|
|
fmt.Println("The smallest power of 2 above 1000 is", num)
|
|
}
|
|
```
|
|
|
|
## Replacement for do-while-loop
|
|
The do-while-loop is useful as the statement is executed at least once before the condition is checked and continue until the condition is no longer true. To simulate the do-while-loop of other languages we can use an infinite for loop with a break condition at the end. The traditional do-while has the following syntax.
|
|
|
|
```
|
|
do {
|
|
statement
|
|
} while (condition);
|
|
```
|
|
We can simulate this syntax in go as follows:
|
|
```
|
|
for {
|
|
statement
|
|
if (!condition) { break }
|
|
}
|
|
|
|
```
|
|
A Go example
|
|
```go
|
|
x := 0
|
|
for {
|
|
// These statements are ran at least once
|
|
x++
|
|
fmt.Println(x)
|
|
|
|
// Check do the condition at the end. If it is no longer true end the loop
|
|
if !(x < 10) {
|
|
break
|
|
}
|
|
}
|
|
```
|