Vad är skillnaden mellan arrays och slices?

Question

Accepted Answer

En **array** har en fast storlek som är del av dess typ; en **slice** är en flexibel, dynamiskt storleksanpassad vy in i en underliggande array. I praktiken använder du nästan alltid **slices** — arrays är sällsynta i vardaglig Go.

## Arrays — fast storlek

```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-storlek är fixerad vid kompileringstillfället och är del av dess typ (`[5]int` ≠ `[3]int`). Arrays är också **värdetyper** — att tilldela eller passera en kopierar hela arrayen. Denna styvhet är anledningen till att de sällan används direkt.

## Slices — dynamiska och flexibla

```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 storlek — du växer den med `append`. Det är det går-to dynamiska sekvensverktyget.

## Hur slices fungerar under huven

```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 skapar en vy (delad underliggande array — en 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]`) kopierar inte — det skapar ett nytt slice header som pekar på **samma** underliggande array. Att modifiera en kan påverka den andra — en vanlig källa till subtila buggar. Använd `copy()` för en oberoende kopia.

## append's reallokeringsöverraskning

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

## Varför det spelar roll

Slices är en av Gos mest använda och mest missförstådda funktioner.

Att förstå att arrays är fast-storleks värdetyper (sällan använda direkt) medan **slices** är flexibla, referens-liknande vyer in i en underliggande array (vardagsverktyget) är fundamental.

Viktigt är att veta om det **delade-underliggande-array-beteendet** — att slicing skapar en vy, inte en kopia, så ändringar kan påverka andra slices, och att `append` kan eller kanske inte reallokar — förhindrar en klass av subtila, svåra-att-debugga alias-buggar som till och med erfarna utvecklare åker på.

Att bemästra slices (len vs cap, append, copy, delnings-gotchas) är väsentlig vardaglig Go-kunskap och ett ofta förekommande intervjuämne, eftersom nästan allt samlings arbete använder dem.