Wat is het verschil tussen arrays en slices?

Question

Accepted Answer

Een **array** heeft een vaste grootte die deel van zijn type is; een **slice** is een flexibel, dynamisch-gesized view in een onderliggende array. In de praktijk gebruik je bijna altijd **slices** — arrays zijn zeldzaam in dagelijks Go-werk.

## Arrays — vaste grootte

```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-grootte is vastgesteld op compile-time en is onderdeel van het type (`[5]int` ≠ `[3]int`). Arrays zijn ook **value types** — toewijzen of doorgeven van één kopieert de hele array. Deze rigiditeit is de reden waarom ze zelden direct gebruikt worden.

## Slices — dynamisch en flexibel

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

Een slice heeft geen vaste grootte — je vergroot het met `append`. Het is het go-to dynamische sequence.

## Hoe slices onder de motorkap werken

```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 creëert een view (gedeelde backing array — een 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]`) kopieert niet — het creëert een nieuwe slice header die naar **dezelfde** onderliggende array wijst. Het wijzigen van een kan de ander beïnvloeden — een veelvoorkomende bron van subtiele bugs. Gebruik `copy()` voor een onafhankelijke kopie.

## append's reallocatie verrassing

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

## Waarom het belangrijk is

Slices zijn een van Go's meest gebruikte en meest misverstane features.

Begrijpen dat arrays vaste-grootte value types zijn (zelden direct gebruikt) terwijl **slices** flexibel, reference-achtige views in een backing array zijn (het dagelijkse tool) is fundamenteel.

Crucaal is het kennen van het **shared-backing-array-gedrag** — dat slicing een view creëert, geen kopie, dus wijzigingen kunnen andere slices beïnvloeden, en dat `append` al dan niet opnieuw kan toewijzen — voorkomt een klasse van subtiele, moeilijk-te-debuggen aliasing bugs die zelfs ervaren developers vangen.

Slices beheersen (len vs cap, append, copy, de sharing gotchas) is essentiële dagelijkse Go-kennis en een veelvuldig interviewonderwerp, omdat bijna al het collection-werk deze gebruikt.