
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


Go's `switch` statement does not fall through by default - each matched case runs and exits. This removes a whole class of bugs common in C and Java. Cases can match multiple values, and a `switch` with no expression works like an `if/else if` chain.

<ExamplePair>
<ExampleProse>

Basic switch on a value. No `break` needed - Go exits automatically after each case body.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    day := "Monday"

    switch day {
    case "Saturday", "Sunday":
        fmt.Println("weekend")
    case "Monday":
        fmt.Println("start of week")
    default:
        fmt.Println("weekday")
    }
    // start of week
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A switch without an expression is equivalent to `switch true` - cases contain boolean conditions, just like `if/else if` but more readable for multiple branches.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    n := 42

    switch {
    case n < 0:
        fmt.Println("negative")
    case n == 0:
        fmt.Println("zero")
    case n < 100:
        fmt.Println("small positive")
    default:
        fmt.Println("large positive")
    }
    // small positive
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A type switch dispatches on the dynamic type of an interface value. The variable in the `case` clause is re-bound to the concrete type inside each branch.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int: %d", v)
    case string:
        return fmt.Sprintf("string: %q", v)
    case bool:
        return fmt.Sprintf("bool: %t", v)
    default:
        return fmt.Sprintf("unknown: %T", v)
    }
}

func main() {
    fmt.Println(describe(42))      // int: 42
    fmt.Println(describe("hello")) // string: "hello"
    fmt.Println(describe(true))    // bool: true
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Type switches are idiomatic Go for interface dispatch - cleaner than a chain of type assertions with ok-checking. They are the primary tool for polymorphism in codebases that avoid deep interface hierarchies. If you need fall-through behaviour (rare), use the explicit `fallthrough` keyword; it must be the last statement in the case body and it skips the condition check on the next case.
</InProduction>


Switch expressions with no fall-through, multi-value cases, init statements, and type switches for interface dispatch.

Switch


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.