Golang for Loop: All Four Forms with Examples

Go has exactly one loop keyword: for. It has four shapes, and between them they cover every loop you would write with for, while, do while or foreach in other languages.

package main

import "fmt"

func main() {
	// 1. three-clause loop
	for i := 0; i < 3; i++ {
		fmt.Println("count", i)
	}

	// 2. condition only (a while loop)
	n := 20
	for n > 1 {
		n /= 2
	}
	fmt.Println("n ended at", n)

	// 3. infinite loop with break
	tries := 0
	for {
		tries++
		if tries == 4 {
			break
		}
	}
	fmt.Println("tries:", tries)

	// 4. range
	for i, fruit := range []string{"apple", "kiwi"} {
		fmt.Println(i, fruit)
	}
}

No parentheses go around the loop header, and braces are always required.

The Three-Clause Loop

for init; condition; post {
	// body
}

1. init runs once before the loop. It is usually a short variable declaration like i := 0, and that variable exists only inside the loop.
2. condition is checked before every iteration. When it is false, the loop ends.
3. The body runs.
4. post runs after each iteration, typically i++.

package main

import "fmt"

func main() {
	// count down
	for i := 5; i > 0; i-- {
		fmt.Print(i, " ")
	}
	fmt.Println("liftoff")

	// step by 10
	for x := 0; x <= 50; x += 10 {
		fmt.Print(x, " ")
	}
	fmt.Println()

	// two variables at once (parallel assignment in post)
	word := []rune("racecar")
	isPalindrome := true
	for i, j := 0, len(word)-1; i < j; i, j = i+1, j-1 {
		if word[i] != word[j] {
			isPalindrome = false
			break
		}
	}
	fmt.Println("racecar is a palindrome:", isPalindrome)
}

i++ is a statement in Go, not an expression, so post cannot contain i++, j--. Use a parallel assignment instead: i, j = i+1, j-1.

All three clauses are optional. for ; i < 10; {} is legal, and gofmt rewrites it to for i < 10 {}, which is the next form.

Condition-Only Loop (Go's while)

With just a condition, for behaves like while in other languages:

package main

import "fmt"

func main() {
	// Collatz sequence: how many steps to reach 1?
	n, steps := 27, 0
	for n != 1 {
		if n%2 == 0 {
			n /= 2
		} else {
			n = 3*n + 1
		}
		steps++
	}
	fmt.Println("steps:", steps)
}

There is no separate do while. The while loop page shows how to get "run at least once" behavior.

Infinite Loops

for with nothing after it loops forever. Leave it with break, return, os.Exit or a panic:

for {
	line, err := reader.ReadString('\n')
	if err != nil {
		break
	}
	process(line)
}

This is the standard shape for servers, workers and input loops. A for {} with an empty body burns a CPU core; in real code, the body blocks on something (a read, a channel receive, a select).

range Loops

range iterates over a collection and yields one or two values per iteration. What they are depends on what you range over:

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	nums := []int{10, 20, 30}
	for i, v := range nums {
		fmt.Printf("nums[%d] = %d\n", i, v)
	}

	// only values: discard the index with _
	sum := 0
	for _, v := range nums {
		sum += v
	}
	fmt.Println("sum:", sum)

	// only indexes: omit the second variable
	for i := range nums {
		nums[i] *= 2
	}
	fmt.Println(nums)

	// a string yields runes
	for i, r := range "héllo" {
		fmt.Print(i, ":", string(r), " ")
	}
	fmt.Println()

	// a map yields keys and values in random order, so sort the keys
	ages := map[string]int{"Ben": 25, "Ana": 31, "Chen": 28}
	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}

	// an integer (Go 1.22)
	for i := range 3 {
		fmt.Print(i, " ")
	}
	fmt.Println()
}

Three details the output shows:

• The value variable is a copy. v *= 2 inside the loop would not change the slice; to modify elements, index into the slice with nums[i], as the third loop does.
• A string's index is a byte offset. é takes two bytes, so the index jumps from 1 to 3.
• Map order is random on purpose. Go randomizes it so code cannot depend on it. slices.Sorted(maps.Keys(m)) (Go 1.23) gives the keys in order.

range is covered in full, including channels, iterator functions and the copying rules, on the range page.

break and continue

break ends the innermost loop. continue skips to the next iteration (running post first, in a three-clause loop):

package main

import "fmt"

func main() {
	for i := range 10 {
		if i%2 == 0 {
			continue // skip even numbers
		}
		if i > 7 {
			break // stop entirely
		}
		fmt.Print(i, " ")
	}
	fmt.Println()
}

Labeled break and continue

A plain break only leaves the innermost loop. To exit an outer loop from inside a nested one, label the outer loop:

package main

import "fmt"

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

	target := 42
	found := false

search:
	for r, row := range grid {
		for c, v := range row {
			if v == target {
				fmt.Printf("found %d at row %d, col %d\n", target, r, c)
				found = true
				break search
			}
		}
	}
	fmt.Println("found:", found)

	// continue with a label skips to the outer loop's next iteration
rows:
	for _, row := range grid {
		for _, v := range row {
			if v%2 == 0 {
				fmt.Println("row with first even number", v)
				continue rows
			}
		}
	}
}

A label is an identifier followed by a colon, placed directly before the for. Go reports an unused label as a compile error, just like an unused variable.

break inside switch and select

Inside a for, a break in a switch or select case leaves the switch or select, not the loop:

for {
	switch cmd := next(); cmd {
	case "quit":
		break // only exits the switch; the loop keeps running
	}
}

Use a labeled break, or return, to leave the loop from inside a switch or select.

Loop Variables Since Go 1.22

Go 1.22 changed the scope of loop variables: each iteration now gets a fresh copy of i and v. Before, one variable was reused for the whole loop, which broke closures and goroutines that captured it:

package main

import (
	"fmt"
	"sync"
)

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()

	var wg sync.WaitGroup
	results := make([]string, 3)
	for i, name := range []string{"a", "b", "c"} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results[i] = name + name
		}()
	}
	wg.Wait()
	fmt.Println(results)
}

With Go 1.22 and later this prints 0 1 2 and [aa bb cc]. Under the old semantics the same program written with for i := 0; i < 3; i++ (range over an integer did not exist before 1.22) printed 3 3 3, and the goroutines raced on the shared i and name. The old workaround, i := i at the top of the loop body, is no longer needed.

The behavior is chosen per module by the go line in go.mod, not by the compiler version. A module that still says go 1.21 keeps the old semantics even when built with Go 1.24.

Common Mistakes

Modifying the copy. for _, v := range items { v.Count++ } changes a copy. Use items[i].Count++, or range over a slice of pointers.

Appending while ranging. range evaluates the slice once, at the start. Elements appended inside the loop are not visited, so the loop still terminates, but it will not see the new items.

Deleting from a slice by index in a forward loop. Removing element i shifts the rest left, so the next element gets skipped. Build a new slice, loop backwards, or use slices.DeleteFunc.

Off-by-one with <=. for i := 0; i <= len(s); i++ reads s[len(s)] on the last pass and panics with index out of range. Use <, or better, range.

Heavy work in the condition. The condition runs every iteration. for i := 0; i < expensiveCount(); i++ calls the function each time; compute it once before the loop.

Using a float as a counter. for x := 0.0; x != 1.0; x += 0.1 never ends, because 0.1 has no exact binary representation. Count with an integer and compute the float from it.

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