Go provides three types of loops to handle repetitive tasks: the for loop, which is the only looping construct in Go. Unlike some other languages, Go does not have while or do-while loops. Instead, the for loop in Go is versatile and can be used in multiple ways to achieve the functionality of traditional loops like while or do-while.

Here are the different forms of the for loop in Go:

---

1. Basic for Loop

The basic for loop is similar to the for loop in other languages. It has three components:

• Initialization: Executes once at the beginning.
• Condition: Checks whether the loop should continue or stop.
• Post Statement: Executes after each iteration.

Syntax:

for initialization; condition; post {
    // Code to execute in each iteration
}

Example:

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}

Explanation:

• Initialization: i := 0 initializes i.
• Condition: i < 5 checks if i is less than 5.
• Post: i++ increments i after each iteration.
• This loop will print the values 0 through 4.

---

2. for Loop as a while Loop

Go does not have a while loop, but you can easily simulate it using a for loop. If you omit the initialization and post statements, the for loop works like a traditional while loop.

Syntax:

for condition {
    // Code to execute while condition is true
}

Example:

package main

import "fmt"

func main() {
    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }
}

Explanation:

• The loop will continue to execute as long as i is less than 5.
• There’s no initialization or post statement; the loop behaves like a while loop.

---

3. Infinite for Loop

You can create an infinite loop by omitting all three components of the for loop. This loop will continue indefinitely until explicitly broken with a break statement or another control flow mechanism like a return or panic.

Syntax:

for {
    // Infinite loop, runs forever unless broken
}

Example:

package main

import "fmt"

func main() {
    i := 0
    for {
        fmt.Println(i)
        i++
        if i == 5 {
            break
        }
    }
}

Explanation:

• The loop runs infinitely but is stopped when i reaches 5.
• The break statement exits the loop once the condition is met.

---

4. for Loop with continue

The continue statement allows you to skip the current iteration and move to the next iteration of the loop.

Example:

package main

import "fmt"

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

Explanation:

• When i is 2, the continue statement is executed, skipping the fmt.Println(i) for that iteration.
• The output will be 0, 1, 3, 4 because the loop skips printing when i is 2.

---

5. for Loop with break

The break statement is used to exit the loop prematurely, regardless of the loop’s condition.

Example:

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            break
        }
        fmt.Println(i)
    }
}

Explanation:

• The loop will print 0, 1, 2 and will exit when i equals 3 due to the break statement.

---

Summary of Loop Types in Go

Loop Type	Description	Example Use Case
Basic for loop	Loops with initialization, condition, and post statements	Iterating over a known range or fixed condition
for as a while loop	Omits initialization and post statements to act like while	Loops based on a condition only
Infinite for loop	Omits all components, resulting in an infinite loop	Continuous execution until explicitly stopped
for loop with continue	Skips the current iteration and proceeds to the next one	Skip specific iterations based on a condition
for loop with break	Exits the loop early when a condition is met	Stop the loop based on a specific condition

---

Conclusion

Go uses a single looping construct — the for loop — to handle all forms of iteration. Whether you're using it as a traditional for loop, a while loop, or even for infinite loops, the flexibility of the for statement makes it highly versatile. With the addition of break and continue, Go provides a powerful control flow mechanism for managing loops in various scenarios.