Arrays

Declaration

Declare an array by specifying its length and element type:

var nums [5]int          // length 5, zero-valued
fmt.Println(nums)         // [0 0 0 0 0]

Initialization

// Explicit length
a := [5]int{1, 2, 3, 4, 5}

// Let Go count for you
b := [...]int{10, 20, 30}
fmt.Println(len(b))           // 3

// Index-based init (sparse)
c := [5]int{2: 99, 4: 88}     // [0 0 99 0 88]

Access & modification

a := [3]string{"go", "rust", "python"}
fmt.Println(a[0])             // go
a[1] = "zig"
fmt.Println(a)                // [go zig python]
fmt.Println(len(a))           // 3

Out-of-bounds access panics at runtime.

Copy semantics

Arrays are value types: assignment and function calls copy them in full.

a := [3]int{1, 2, 3}
b := a                 // full copy
b[0] = 99
fmt.Println(a, b)      // [1 2 3] [99 2 3]

This can be expensive for large arrays. Passing [1000000]int to a function means copying a million ints. Use slices or a pointer (*[N]int) for big arrays.

Comparison

Arrays of comparable element types are ==-comparable:

fmt.Println([3]int{1, 2, 3} == [3]int{1, 2, 3})   // true
fmt.Println([3]int{1, 2, 3} == [3]int{1, 2, 4})   // false

This is one thing slices can't do. Slices are not comparable with == (except to nil).

Multi-dimensional

var grid [3][3]int
grid[1][2] = 7
fmt.Println(grid)    // [[0 0 0] [0 0 7] [0 0 0]]

Arrays vs slices (and when to use arrays)

Slices are dynamic, share-by-reference, and can be passed around cheaply. Arrays are fixed and value-typed. Prefer slices unless:

• The size is small, constant, and compile-time known (e.g. [16]byte for a hash).
• You want value semantics, meaning automatic copy on assignment.
• You want == comparison.
• You're matching a specific binary layout (network protocol, crypto).

Check your understanding

Practice exercises

func reverse(a [5]int) [5]int {
    var r [5]int
    for i, v := range a {
        r[len(a)-1-i] = v
    }
    return r
}