An array has a fixed size that's part of its type; a slice is a flexible, dynamically-sized view into an underlying array. In practice you almost always use slices — arrays are rare in everyday Go.
arr []
arr[] =
fmt.Println((arr))
Array size is fixed at compile time and part of its type ([5]int ≠ [3]int). Arrays are also value types — assigning or passing one copies the whole array. This rigidity is why they're seldom used directly.
s := []int{1, 2, 3} // a slice (no size in the brackets)
s = append(s, 4) // grow it — append returns a new slice
fmt.Println(len(s), cap(s)) // length and capacity
nums := make([]int, 0, 10) // make a slice: length 0, capacity 10 (pre-allocated)
A slice has no fixed size — you grow it with append. It's the go-to dynamic sequence.
A slice is a small struct: { pointer to underlying array, length, capacity }
- len = number of elements currently in the slice
- cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
original := []int{1, 2, 3, 4, 5}
sub := original[1:3] // [2, 3] — a VIEW into the same backing array
sub[0] = 99 // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
Slicing (s[low:high]) doesn't copy — it creates a new slice header pointing at the same underlying array. Modifying one can affect the other — a common source of subtle bugs. Use copy() for an independent copy.
a := []int{1, 2, 3}
b := append(a, 4) // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
Slices are one of Go's most-used and most-misunderstood features.
Understanding that arrays are fixed-size value types (rarely used directly) while slices are flexible, reference-like views into a backing array (the everyday tool) is fundamental.
Crucially, knowing the shared-backing-array behavior — that slicing creates a view, not a copy, so modifications can affect other slices, and that append may or may not reallocate — prevents a class of subtle, hard-to-debug aliasing bugs that catch even experienced developers.
Mastering slices (len vs cap, append, copy, the sharing gotchas) is essential everyday Go knowledge and a frequent interview topic, since nearly all collection work uses them.
A library of IT interview questions with detailed answers — from Junior to Senior.
Donate