Hvad er forskellen mellem arrays og slices?

Question

Accepted Answer

Et **array** har en fast størrelse, der er en del af dets type; en **slice** er en fleksibel, dynamisk stor visning ind i et underliggende array. I praksis bruger du næsten altid **slices** — arrays er sjældne i hverdags-Go.

## Arrays — fast størrelse

```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-størrelse er fastsat ved kompileringstid og er en del af dets type (`[5]int` ≠ `[3]int`). Arrays er også **værdi-typer** — at tildele eller overføre en kopi af hele arrayet. Denne stivhed er hvorfor de sjældent bruges direkte.

## Slices — dynamisk og fleksibel

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

En slice har ingen fast størrelse — du vokser den med `append`. Det er det daglige dynamiske sekvens-værktøj.

## Hvordan slices fungerer under motorhjelmen

```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 skaber en visning (delt underliggende array — en fælde)

```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]`) kopierer ikke — det skaber et nyt slice-header, der peger på det **samme** underliggende array. At ændre det ene kan påvirke det andet — en almindelig kilde til subtile fejl. Brug `copy()` for en uafhængig kopi.

## append's omfordelings-overraskelse

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

## Hvorfor det betyder noget

Slices er en af Gos mest-brugte og mest-misforståede features.

At forstå, at arrays er fast-størrelse værdi-typer (sjældent brugt direkte), mens **slices** er fleksible, reference-lignende visninger ind i et underliggende array (det daglige værktøj), er grundlæggende.

Vigtigst er det at kende **den delte-underliggende-array-opførsel** — at slicing skaber en visning, ikke en kopi, så ændringer kan påvirke andre slices, og at `append` kan eller ikke kan omfordele — forhindrer en klasse af subtile, svære at debugge aliasing-fejl, som fanger selv erfarne udvikler.

At mestre slices (len vs cap, append, copy, de delte fælder) er væsentlig hverdags-Go-viden og et hyppigt interview-emne, da næsten alt samlingsarbejde bruger dem.