Array

An array in Go is a homogeneous, fixed-size data structure consisting of a contiguous sequence of elements of a single type. The length of an array is an intrinsic part of its type signature, meaning arrays cannot be resized after declaration, and arrays of different lengths (e.g., [3]int and [5]int) are considered distinct, incompatible types by the compiler.

Backing Store for Slices

In idiomatic Go, arrays are rarely manipulated directly. Their primary architectural purpose is to serve as the underlying, fixed-size backing store for slices. Slices act as dynamic, reference-like descriptors that provide a window over these contiguous array memory blocks.

Memory and Value Semantics

Unlike arrays in languages like C or Java, Go arrays are values, not implicit pointers to the first element.

• Assigning one array to another copies all elements.
• Passing an array to a function passes a complete copy of the array. The memory allocation for this copy is determined by Go’s escape analysis; it may be allocated on the stack or escape to the heap. Additionally, under Go’s register-based calling convention, small arrays may be passed entirely in CPU registers rather than occupying memory.
• To avoid copying large arrays, you must explicitly pass a pointer to the array (e.g., *[5]int).

Comparability

Arrays are comparable if their underlying element type is comparable. Two arrays of the same type can be compared using the == and != operators, evaluating to true if all corresponding elements are equal. Because of this property, arrays can be used as map keys—a vital distinction from slices, which are not comparable.

a := [2]int{1, 2}
b := [2]int{1, 2}
c := [2]int{2, 1}

isEqual := a == b    // true
isNotEqual := a == c // false

// Arrays used as map keys
coordinateMap := map[[2]int]string{
    {0, 0}: "Origin",
    {1, 5}: "Point A",
}

Declaration and Initialization

When declared without explicit initialization, an array’s elements are automatically initialized to the zero value of their underlying type.

// Standard declaration: creates an array of 5 integers.
// Memory is allocated and initialized to zero values: [0 0 0 0 0]
var buffer [5]int 

// Array literal initialization
matrix := [3]float64{1.5, 2.0, 3.14}

// Compiler-inferred length using the ellipsis (...) operator
// The compiler counts the elements to determine the type is [4]string
protocols := [...]string{"http", "https", "tcp", "udp"}

// Sparse initialization using index keys
// Initializes indices 2 and 4; all other indices default to 0
// Result: [0 0 100 0 200]
sparse := [5]int{2: 100, 4: 200}

Element Access and Built-in Functions

Array elements are accessed using zero-based indexing. The Go compiler performs bounds checking; attempting to access an index outside the array’s length results in a compile-time error (if the index is a constant) or a runtime panic.

var sequence [3]int
sequence[0] = 10       // Assignment
value := sequence[0]   // Retrieval

// Built-in functions
size := len(sequence)     // Returns the length of the array (3)
capacity := cap(sequence) // Returns the capacity (always equals length for arrays)

Iteration

Arrays can be traversed using a standard for loop or the range keyword. The range keyword yields both the index and a copy of the value at that index.

collection := [...]int{10, 20, 30}

// Iterating using range
for index, value := range collection {
    // 'value' is a copy of collection[index]
}

// Omitting the index using the blank identifier
for _, value := range collection {
    // process value
}

Multi-dimensional Arrays

Go supports multi-dimensional arrays by composing arrays of arrays. The length of every dimension must be defined at compile time.

// A 2x3 two-dimensional array of integers
var grid [2][3]int

// Initialization of a multi-dimensional array
identity := [2][2]int{
    {1, 0},
    {0, 1},
}

Master Go with Deep Grasping Methodology!

Learn More