Arrays

Introduction

An array in Go is a fixed-size, ordered collection of elements that all share the same type. Once you declare an array with a given length, that length is baked into the array's type and can never change. Arrays are the foundation that Go's much more commonly used slices are built on top of, so understanding them well makes slices click much faster.

Declaring Arrays

An array type is written as [n]T, where n is the fixed number of elements and T is the element type. The size is part of the type itself — [3]int and [5]int are different, incompatible types.

package main

import "fmt"

func main() {
	// Zero-valued array: all elements start at 0.
	var scores [3]int
	fmt.Println(scores)

	// Array literal with explicit values.
	names := [3]string{"Alice", "Bob", "Charlie"}
	fmt.Println(names)

	// Let the compiler count the elements with "...".
	primes := [...]int{2, 3, 5, 7, 11}
	fmt.Println(primes, "length:", len(primes))
}

Indexing and Length

Array elements are accessed with zero-based indexing, just like slices. The built-in len function returns the number of elements. Accessing an index outside the valid range causes a runtime panic, so bounds matter.

package main

import "fmt"

func main() {
	temps := [5]float64{72.5, 75.0, 68.3, 70.1, 74.8}

	fmt.Println("First reading:", temps[0])
	fmt.Println("Last reading:", temps[len(temps)-1])

	temps[2] = 69.9 // update an element
	fmt.Println("Updated:", temps)
}

Iterating Over Arrays

The range keyword works on arrays just as it does on slices, giving you both the index and the value on each iteration.

package main

import "fmt"

func main() {
	grades := [4]int{88, 92, 75, 100}

	total := 0
	for i, grade := range grades {
		fmt.Printf("Student %d scored %d\n", i+1, grade)
		total += grade
	}

	average := float64(total) / float64(len(grades))
	fmt.Printf("Average: %.2f\n", average)
}

Arrays Are Value Types

This is the single most important fact about Go arrays: they are value types, not reference types. When you assign an array to a new variable, or pass it to a function, Go copies the entire array. Modifying the copy never affects the original. This is a common source of confusion for developers coming from languages where arrays are always references.

package main

import "fmt"

func tryToModify(arr [3]int) {
	arr[0] = 999 // modifies the local copy only
}

func main() {
	original := [3]int{1, 2, 3}
	copied := original // full copy happens here

	copied[0] = 100

	fmt.Println("original:", original)
	fmt.Println("copied:  ", copied)

	tryToModify(original)
	fmt.Println("after function call:", original)
}

Multi-Dimensional Arrays

Go supports arrays of arrays, giving you multi-dimensional grids such as matrices or game boards.

package main

import "fmt"

func main() {
	var board [3][3]string

	for i := range board {
		for j := range board[i] {
			board[i][j] = "-"
		}
	}
	board[1][1] = "X"

	for _, row := range board {
		fmt.Println(row)
	}
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Arrays give Go a fixed-size, value-type collection that's predictable and cheap for small, known sizes — but their inflexibility is exactly what slices were designed to fix. Next, you'll learn about slices, the dynamic, flexible collection type that Go developers reach for in almost every situation.