What is the difference between arrays and slices?

Question

Accepted Answer

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.

## Arrays — fixed size

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

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.

## Slices — dynamic and flexible

```go
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.

## How slices work under the hood

```text
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
```

## Slicing creates a view (shared backing array — a gotcha)

```go
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.

## append's reallocation surprise

```go
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)
```

## Why it matters

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.