for Loop Variants & range Semantics

Go expresses every loop with for, but the shape you choose changes what you copy, what you can mutate, and when the loop stops.

This page maps each for variant to the collections and channels you will see in production code.

Summary

The three-part for header covers counted loops.

The condition-only form acts like while.

for range walks slices, arrays, maps, channels, and strings with type-specific index/value meaning.

Channels block until a value arrives or the channel closes.

Maps iterate in randomized order.

Strings yield byte offsets and runes, not bytes directly.

Recipe

Quick-reference recipe card - copy-paste ready.

package main
 
import "fmt"
 
func main() {
    // C-style
    for i := 0; i < 3; i++ {
        fmt.Println("count", i)
    }
 
    // while-style
    n := 3
    for n > 0 {
        n--
    }
 
    // range slice
    for i, v := range []int{10, 20} {
        fmt.Println(i, v)
    }
}

When to reach for this:

• Use three-part for when you need an index counter with a clear end condition.
• Use condition-only for for event loops, retries, and channel pumps (for { select { ... } }).
• Use for range for idiomatic iteration over collections and open channels.
• Use for range over 1..n alternatives via slices or for i := 0; i < n; i++ - Go has no inclusive range operator.

Working Example

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    // Slice: mutate by index
    nums := []int{1, 2, 3}
    for i := range nums {
        nums[i] *= 2
    }
    fmt.Println("slice", nums)
 
    // Map: keys and values (order varies each run)
    m := map[string]int{"a": 1, "b": 2}
    for k, v := range m {
        fmt.Println("map", k, v)
    }
 
    // Channel: receive until closed
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    close(ch)
    for v := range ch {
        fmt.Println("chan", v)
    }
 
    // String: byte index and rune
    for i, r := range "Go🙂" {
        fmt.Printf("string i=%d r=%U\n", i, r)
    }
 
    // Infinite loop with timeout break
    deadline := time.Now().Add(50 * time.Millisecond)
    for {
        if time.Now().After(deadline) {
            break
        }
    }
    fmt.Println("done")
}

What this demonstrates:

• Slice mutation requires index access, not the range value copy.
• Map iteration order is not stable - never depend on it.
• for range on a channel ends when the channel is closed and drained.
• String range decodes UTF-8 runes; index jumps by byte width for multibyte characters.
• Condition-only infinite loops pair with break, return, or select.

Deep Dive

How It Works

• for creates a block scope; the init variable in a three-part loop is scoped to the for statement.
• range evaluates the collection once; for arrays/slices it copies the header, not the backing array elements.
• Channel receive in for range blocks until a value is ready; zero value plus ok pattern is implicit in range form.
• Map iterators pick random start buckets - order differs across processes and runs by design.
• String range converts bytes to runes; len(s) is byte length, which differs from rune count.

range by Type

for Loop Shapes

Go Notes

// Omit value or index with blank identifier
for _, v := range items { _ = v }
for i := range items { _ = i }
 
// range over array copies elements for value form on large arrays - use index
var big [10000]byte
for i := range big {
    big[i] = 1
}

Gotchas

• Mutating slice elements via range value - for _, v := range s { v = 1 } updates a copy. Fix: use index: for i := range s { s[i] = 1 }.
• Depending on map iteration order - Tests assuming key order flake. Fix: sort keys first or compare multisets.
• Ranging an open channel forever - Without close, for range ch blocks forever. Fix: close from sender side or use select with ctx.Done().
• Confusing string length with rune count - len("é") is 2 bytes in UTF-8. Fix: use range or utf8.RuneCountInString.
• Large array range copies - Ranging over array value copies each element. Fix: range indices on arrays or use slices.
• Off-by-one with three-part loops - Using <= when < was intended. Fix: prefer for i := 0; i < len(s); i++ idioms.

Alternatives

FAQs

Related

• Control Flow Basics - intro snippets for for and range
• break, continue & Labeled Control Flow - exiting nested loops
• range Variable Reuse Pitfalls - closure capture in loops
• Go Control Flow: Expression-Oriented Design - conceptual overview
• Arrays, Slices & Maps at a Glance - collection types iterated here

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).