
Go has exactly one loop keyword: `for`. It handles every looping pattern - from a classic counter loop to an infinite loop to iterating over collections with `range`. There is no `while` or `do/while`.

<ExamplePair>
<ExampleProse>

The classic three-component `for` loop: initialiser, condition, post statement. All three are optional.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    // Classic counter loop
    for i := 0; i < 3; i++ {
        fmt.Println(i)
    }
    // 0
    // 1
    // 2
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

With only a condition, `for` behaves like `while` in other languages.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    n := 1
    for n < 100 {
        n *= 2
    }
    fmt.Println(n) // 128
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

With no condition at all, `for` loops forever. Break out with `break` or return from the function.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

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

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`range` iterates over slices, arrays, maps, strings, and channels. It returns an index (or key) and a value on each iteration. Use `_` to discard either.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    nums := []int{10, 20, 30}

    for i, v := range nums {
        fmt.Println(i, v)
    }
    // 0 10
    // 1 20
    // 2 30

    // Discard the index
    for _, v := range nums {
        fmt.Println(v)
    }

    // range over a map (iteration order is random)
    m := map[string]int{"a": 1, "b": 2}
    for k, v := range m {
        fmt.Println(k, v)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`range` over a slice gives a *copy* of each element - assigning to the range variable does not mutate the slice. Use the index form `for i := range s { s[i] = ... }` to mutate in place. This surprises engineers coming from Python or JavaScript where the range variable is a reference. The same trap applied inside goroutines on Go versions before 1.22: capturing the range variable in a goroutine captured the variable, not its value at that iteration. Go 1.22 changed loop-variable scoping so each iteration gets its own variable, fixing the race automatically. On older toolchains, pass the loop variable as a function argument to get a copy.
</InProduction>


Go's single loop construct - the for statement covers basic loops, while-style loops, infinite loops, and range iteration.


Go's `if` statement works like most languages, with two additions: conditions do not need parentheses, and the `if` statement can include a short initialiser before the condition.

<ExamplePair>
<ExampleProse>

A simple `if`/`else if`/`else` chain. The condition must be a boolean expression - no implicit truthiness.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    x := 7

    if x > 10 {
        fmt.Println("big")
    } else if x > 4 {
        fmt.Println("medium")
    } else {
        fmt.Println("small")
    }
    // medium
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The init-statement form runs a short statement before evaluating the condition. The variable declared in the init is scoped to the entire `if`/`else` block - it does not leak into the surrounding scope.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    if n, err := strconv.Atoi("42"); err == nil {
        fmt.Println("parsed:", n)
    } else {
        fmt.Println("error:", err)
    }
    // parsed: 42

    // n and err are not accessible here
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The init-statement form is most common with error checks: run the operation, capture the error, and handle it - all in one line. The variable declared in the init is not accessible outside the block.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    if f, err := os.Open("data.txt"); err != nil {
        fmt.Println("cannot open:", err)
    } else {
        defer f.Close()
        fmt.Println("opened:", f.Name())
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
The `if err != nil { return err }` pattern is idiomatic Go error handling - not a limitation, but a deliberate design choice that makes error paths explicit at every call site. Avoid nesting multiple init-statement `if` blocks in sequence; a long chain of `if x, err := ...; err != nil { ... }` blocks is harder to follow than extracting the logic into a named function that returns early. Each early return is a documented exit point - that is the intent.
</InProduction>


Conditional branching with if, else if, and else - including the idiomatic init-statement form used for error checks.

If/Else


Constants in Go are values computed at compile time. They can be boolean, numeric, or string. Unlike variables, constants cannot be assigned to at runtime - the compiler enforces this.

<ExamplePair>
<ExampleProse>

`const` declares a single value or a block of values. Constants must be assignable from a literal or a constant expression.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

const Pi = 3.14159
const MaxRetries = 3
const ServiceName = "auth-service"

func main() {
    fmt.Println(Pi, MaxRetries, ServiceName)

    const localTimeout = 30 // constants can be declared inside functions too
    fmt.Println(localTimeout)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`iota` is a compile-time counter that resets to 0 at the start of each `const` block and increments by 1 for each constant. It is the idiomatic way to define enumerations in Go.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Direction int

const (
    North Direction = iota // 0
    East                   // 1
    South                  // 2
    West                   // 3
)

type ByteSize float64

const (
    _           = iota             // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota) // 1024
    MB                             // 1048576
    GB                             // 1073741824
)

func main() {
    fmt.Println(North, East, South, West)
    fmt.Println(KB, MB, GB)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

An *untyped* constant has no explicit type - it adopts a default type at the point of use. A *typed* constant carries its type and will only satisfy type-safe comparisons.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

const untypedMax = 1000        // untyped int constant
const typedMax int32 = 1000    // typed int32 constant

func printInt64(n int64) {
    fmt.Println(n)
}

func main() {
    printInt64(untypedMax) // OK - untyped constant is widened to int64
    // printInt64(typedMax) // compile error: cannot use typedMax (int32) as int64
    _ = typedMax
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Untyped integer constants are assigned a default type (`int`) at the point of use - passing one across a package boundary can produce surprising implicit widening or narrowing depending on the target platform's `int` size (32 vs 64 bits). Typed constants make intent explicit and prevent cross-package confusion. This matters especially for constants used as sizes, capacities, or enum discriminants that flow into serialization formats or database columns where the width is load-bearing.
</InProduction>


const, iota, typed vs untyped constants, and constant expressions evaluated at compile time.