
`range` is Go's universal iteration keyword. It adapts to the type it ranges over: slices give index and value, maps give key and value, strings give byte-index and rune, channels give values as they arrive, and since Go 1.22 integers give a count from 0.

<ExamplePair>
<ExampleProse>

Ranging over a slice yields the index and a copy of the element. Use `_` to discard whichever you don't need.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry"}

    for i, v := range fruits {
        fmt.Println(i, v)
    }
    // 0 apple
    // 1 banana
    // 2 cherry

    // Index only
    for i := range fruits {
        fmt.Println(i)
    }

    // Value only
    for _, v := range fruits {
        fmt.Println(v)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Ranging over a map yields key-value pairs. Map iteration order is deliberately randomised by the runtime on each run.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "sort"
)

func main() {
    scores := map[string]int{"alice": 90, "bob": 85, "carol": 92}

    // Order is non-deterministic
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }

    // Deterministic output - sort keys first
    keys := make([]string, 0, len(scores))
    for k := range scores {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Printf("%s: %d\n", k, scores[k])
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Ranging over a string decodes UTF-8 runes, not bytes. The index is the byte offset of the rune in the string, not its position in a character array.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := "héllo"

    // range gives (byte-index, rune)
    for i, r := range s {
        fmt.Printf("index=%d rune=%c\n", i, r)
    }
    // index=0 rune=h
    // index=1 rune=é  (é is 2 bytes in UTF-8)
    // index=3 rune=l
    // index=4 rune=l
    // index=5 rune=o

    fmt.Println(len(s))         // 6 - byte length
    fmt.Println(len([]rune(s))) // 5 - rune (character) count
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Since Go 1.22, you can range over an integer `n` to iterate from `0` to `n-1` - a concise replacement for `for i := 0; i < n; i++`.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    // Go 1.22+: range over integer
    for i := range 5 {
        fmt.Println(i)
    }
    // 0 1 2 3 4
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Two surprises appear constantly in code review. First, map iteration order is non-deterministic - if you need deterministic output (logs, serialized responses, test assertions), sort the keys explicitly before ranging. Second, ranging over a string decodes UTF-8 runes, so the index jumps by byte width, not by 1. `len(s)` returns bytes; `len([]rune(s))` returns rune count. Mixing these silently corrupts string operations on any non-ASCII input - a bug that only surfaces when users with non-Latin names or emoji-heavy data start using your product.
</InProduction>


The range keyword iterates over slices, maps, strings, channels, and integers - each with different iteration semantics worth knowing.

Range over Built-in Types


In Go, a `string` is an immutable sequence of bytes - not characters. Most Go strings happen to be valid UTF-8, but the language does not enforce that. A `rune` is an alias for `int32` and represents a single Unicode code point.

<ExamplePair>
<ExampleProse>

`len(s)` returns the number of bytes, not characters. To count Unicode code points (runes), convert to `[]rune` first or use the `utf8` package.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Hello, 世界"

    fmt.Println(len(s))                    // 13 - bytes
    fmt.Println(utf8.RuneCountInString(s)) // 9  - runes (code points)
    fmt.Println(len([]rune(s)))            // 9  - same, via conversion
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Index a string to get a `byte`. Range over a string to get `rune` values at each Unicode code point. Slicing a string produces bytes - slicing in the middle of a multi-byte rune produces invalid UTF-8.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := "café"

    // Indexing gives bytes - the 'é' spans bytes 3 and 4
    fmt.Printf("%x\n", s[3]) // c3 - first byte of 'é'

    // Range gives runes
    for i, r := range s {
        fmt.Printf("byte %d: %c (%d)\n", i, r, r)
    }
    // byte 0: c (99)
    // byte 1: a (97)
    // byte 2: f (102)
    // byte 3: é (233)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Convert between strings, byte slices, and rune slices explicitly. Each conversion copies the data. Use `strings.Builder` for efficient string construction in a loop - it avoids the repeated allocations of the `+` operator.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello"

    // String <-> []byte (copy)
    b := []byte(s)
    b[0] = 'H'
    fmt.Println(string(b)) // Hello
    fmt.Println(s)         // hello - original unchanged

    // Efficient concatenation with strings.Builder
    var sb strings.Builder
    for i := 0; i < 5; i++ {
        fmt.Fprintf(&sb, "item%d ", i)
    }
    fmt.Println(sb.String()) // item0 item1 item2 item3 item4
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A rune literal is a single Unicode code point in single quotes. The `utf8` package provides utilities for validating and decoding UTF-8 without converting to a rune slice.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    r := 'é'
    fmt.Println(r)          // 233 - the Unicode code point
    fmt.Printf("%c\n", r)   // é

    // Decode the first rune from a byte slice
    s := "café"
    r2, size := utf8.DecodeRuneInString(s)
    fmt.Printf("first rune: %c, byte size: %d\n", r2, size)
    // first rune: c, byte size: 1

    // Validate UTF-8
    fmt.Println(utf8.ValidString(s))      // true
    fmt.Println(utf8.ValidString("\xff")) // false
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`len(s)` returns bytes, not characters - a user-visible "character" may be a multi-rune grapheme cluster (a flag emoji is two runes, a family emoji can be seven). For user-facing string operations such as truncating at N display characters or counting words in a tweet, the stdlib `strings` package works at the byte and rune level and will silently produce wrong counts or broken output on international text. Use `golang.org/x/text` for locale-aware and grapheme-cluster-aware operations. The conversion `[]rune(s)` is correct for most Latin + CJK work but will still count multi-codepoint graphemes incorrectly. Know your input domain before choosing the right level of abstraction.
</InProduction>


Go strings are immutable byte slices encoded in UTF-8. A rune is a Unicode code point (int32) - the distinction matters on any non-ASCII input.

Strings and Runes


A recursive function calls itself until it reaches a base case. Go supports recursion with automatically growing goroutine stacks - you do not need to worry about a fixed stack size as you would in C.

<ExamplePair>
<ExampleProse>

Classic factorial: the base case returns immediately; the recursive case reduces the problem by one step each call.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func factorial(n int) int {
    if n == 0 {
        return 1 // base case
    }
    return n * factorial(n-1)
}

func main() {
    fmt.Println(factorial(5))  // 120
    fmt.Println(factorial(10)) // 3628800
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Two functions can call each other mutually. Go resolves the forward reference at link time, so you only need to declare both functions in the same package.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func isEven(n int) bool {
    if n == 0 {
        return true
    }
    return isOdd(n - 1)
}

func isOdd(n int) bool {
    if n == 0 {
        return false
    }
    return isEven(n - 1)
}

func main() {
    fmt.Println(isEven(8)) // true
    fmt.Println(isOdd(7))  // true
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A closure can refer to itself by assigning it to a variable before the function literal is called.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var fib func(n int) int
    fib = func(n int) int {
        if n <= 1 {
            return n
        }
        return fib(n-1) + fib(n-2)
    }

    for i := 0; i < 8; i++ {
        fmt.Printf("fib(%d) = %d\n", i, fib(i))
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Go does not optimize tail calls - every recursive call adds a frame to the goroutine's stack. Go grows that stack automatically up to a configurable limit (default 1 GB) before panicking with a stack overflow. For deep traversal - parsing deeply nested JSON, walking large directory trees, traversing binary trees with millions of nodes - an explicit stack (a slice used as a LIFO queue) is more predictable: you control memory usage, avoid GC pressure from many small frames, and can apply a depth limit cleanly. Save recursion for cases where the problem depth is bounded and the recursive form is substantially clearer.
</InProduction>


Functions that call themselves - Go supports recursion with automatic goroutine stack growth, though deep trees are better handled with an explicit stack.