
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


A slice is a view into an underlying array. It has three fields: a pointer to the array, a length, and a capacity. Slices are the workhorse collection in Go - dynamic, passed by reference semantics, and composable.

<ExamplePair>
<ExampleProse>

Create a slice with `make([]T, length, capacity)` or with a slice literal. Both are nil-free and immediately usable. `len` returns the number of elements; `cap` returns the underlying array's size from the slice's start.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    // Slice literal
    s := []int{1, 2, 3}
    fmt.Println(s, len(s), cap(s)) // [1 2 3] 3 3

    // make: length 3, capacity 5
    t := make([]int, 3, 5)
    fmt.Println(t, len(t), cap(t)) // [0 0 0] 3 5
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`append` adds elements to a slice. If the slice has spare capacity, it appends in-place and returns a slice with a larger length. If capacity is exhausted, it allocates a new backing array, copies existing elements, and returns a slice pointing to the new array.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := make([]int, 0, 3)

    for i := 0; i < 5; i++ {
        s = append(s, i)
        fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
    }
    // len=1 cap=3 [0]
    // len=2 cap=3 [0 1]
    // len=3 cap=3 [0 1 2]
    // len=4 cap=6 [0 1 2 3]   ← new backing array allocated
    // len=5 cap=6 [0 1 2 3 4]
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A sub-slice `s[low:high]` shares the same backing array as the original. Writes through the sub-slice mutate the original. Use `copy` to get an independent slice.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    orig := []int{1, 2, 3, 4, 5}

    // Sub-slice shares backing array
    sub := orig[1:4]   // [2 3 4]
    sub[0] = 99
    fmt.Println(orig)  // [1 99 3 4 5] - original mutated!

    // Independent copy
    dst := make([]int, len(orig))
    copy(dst, orig)
    dst[0] = 0
    fmt.Println(orig)  // [1 99 3 4 5] - original untouched
    fmt.Println(dst)   // [0 99 3 4 5]
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Two slices sharing a backing array is the most common source of subtle mutation bugs in Go. A sub-slice write reaches through to the parent. In high-throughput services, pre-allocate with `make([]T, 0, n)` when you know the approximate size - it avoids repeated allocations and the GC pressure that comes with them. `append` doubling capacity on each overflow sounds cheap, but 10 000 appends to an unallocated slice trigger ~14 allocations and copies; a single `make` with a sensible capacity eliminates all of them.
</InProduction>


Dynamic sequences built on arrays - make, literals, append, copy, sub-slicing, and the len vs cap distinction.

Slices


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.