
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


An array in Go has a fixed length that is part of its type: `[5]int` and `[10]int` are two distinct types. Arrays are zero-initialised and comparable. In practice, slices (backed by arrays) are used far more often.

<ExamplePair>
<ExampleProse>

Declare an array with `var` - every element is initialised to the zero value of the element type. Use an array literal to initialise with specific values. The `...` syntax infers the length from the literal.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var zeros [5]int
    fmt.Println(zeros) // [0 0 0 0 0]

    primes := [5]int{2, 3, 5, 7, 11}
    fmt.Println(primes) // [2 3 5 7 11]

    // Infer length from literal
    words := [...]string{"foo", "bar", "baz"}
    fmt.Println(len(words)) // 3
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Arrays are comparable with `==` if their element type is comparable. Two arrays are equal when all corresponding elements are equal.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    a := [3]int{1, 2, 3}
    b := [3]int{1, 2, 3}
    c := [3]int{1, 2, 4}

    fmt.Println(a == b) // true
    fmt.Println(a == c) // false
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Multi-dimensional arrays are arrays of arrays. Access with consecutive index expressions.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var grid [3][3]int

    for i := range grid {
        for j := range grid[i] {
            grid[i][j] = i*3 + j
        }
    }

    fmt.Println(grid)
    // [[0 1 2] [3 4 5] [6 7 8]]
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Arrays are value types in Go - assigning or passing them copies every element. Passing a `[10000]byte` to a function copies 10 KB on the stack; you almost always want a slice or a pointer to the array in real code. The fixed-length property makes arrays useful for fixed-size cryptographic or binary structures (e.g., `[32]byte` for a SHA-256 digest), where the size constraint is a feature, not a limitation.
</InProduction>


Fixed-length typed arrays - declaration, zero initialisation, array literals, comparison, and multi-dimensional arrays.

Arrays


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.