Hva er forskjellen mellom arrays og slices?

Question

Accepted Answer

En **array** har en fast størrelse som er en del av typen; en **slice** er en fleksibel, dynamisk stor visning inn i en underliggende array. I praksis bruker du nesten alltid **slices** — arrays er sjeldne i dagligdags 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 fast ved kompileringsstadiet og er en del av typen (`[5]int` ≠ `[3]int`). Arrays er også **verdi-typer** — å tilordne eller sende en kopi av en array vil kopiere hele arrayen. Denne stivheten er grunnen til at de sjelden brukes 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 foretrukne dynamiske sekvens-verktøyet.

## Hvordan slices fungerer under motoren

```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 opprettet en visning (delt backing array — en fallgruve)

```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 opprettet en ny slice-header som peker på **samme** underliggende array. Å modifisere en kan påvirke den andre — en vanlig kilde til subtile feil. Bruk `copy()` for en uavhengig kopi.

## append's omallokerings-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 betyr noe

Slices er en av Gos mest brukte og mest misforstått funksjoner.

Å forstå at arrays er fast-størrelse verdi-typer (sjelden brukt direkte) mens **slices** er fleksible, referanse-lignende visninger inn i en backing array (det dagligdagse verktøyet) er fundamentalt.

Avgjørende er det å kjenne den **delte-backing-array-oppførselen** — at slicing opprettet en visning, ikke en kopi, så modifikasjoner kan påvirke andre slices, og at `append` kanskje eller kanskje ikke realloker — forhindrer en klasse av subtile, vanskelig-debugg-bare aliasing-feil som til og med erfarne utviklere fanger.

Å mestre slices (len vs cap, append, copy, delingsfallgrupene) er essensiell dagligdags Go-kunnskap og et hyppig intervjuemne, siden nesten alt samlingarbeid bruker dem.