The Array–Slice Difference

The difference begins in the type system. An array type includes its length — [3]int — so the value is a fixed block and the compiler knows its shape everywhere. A slice type is []int and carries no length at all; at runtime it is a small three-field header pointing into a backing array, with its own length and capacity. Everything practical follows from this split.

Copying is the clearest consequence. Assigning an array copies every element — y := x produces two independent values. Assigning a slice copies only the header — t := s leaves two headers pointing at the same elements, so writes through either are visible in both:

x := [3]int{10, 20, 30}
y := x
y[0] = 7
fmt.Println(x, y) // [10 20 30] [7 20 30] — independent

s := []int{10, 20, 30}
t := s
t[0] = 7
fmt.Println(s, t) // [7 20 30] [7 20 30] — shared storage

Comparison rules differ for the same reason. Two arrays of one type compare element-wise ([3]int{1,2,3} == [3]int{1,2,3} is true). A slice cannot be the operand of == (except s == nil) because a meaningful equality would have to define what it means for two windows over shared, growable storage — so Go declines. Zero values match the pictures too: an uninitialized array is a full block of zeroed elements, an uninitialized slice is nil.

In practice: use the array when the bound is meaning (a [32]byte digest) or isolation is wanted; use the slice — the default — whenever length varies or the data must travel between functions cheaply, since passing a slice copies only the header.