Hvordan fungerer maps i Go?

Question

Accepted Answer

Et **map** er Gos innebygde hash-tabell — en uordnet samling av **nøkkel-verdi-par** med O(1) gjennomsnittlig oppslag. Det er standardmåten å knytte nøkler til verdier.

## Opprette og bruke maps

```go
// create with make
ages := make(map[string]int)    // map from string keys to int values
ages["Ann"] = 30                 // set
age := ages["Ann"]               // get → 30

// or with a literal
scores := map[string]int{
    "math":    90,
    "science": 85,
}

delete(scores, "math")           // remove a key
len(scores)                       // number of entries
```

## comma-ok idiom — å skille mellom "mangler" og "null"

```go
// ⚠️ a missing key returns the ZERO VALUE, not an error
value := scores["missing"]       // 0 — but was it stored as 0, or absent? Ambiguous!

// ✅ the comma-ok form tells you if the key EXISTS
value, ok := scores["missing"]
if ok {
    fmt.Println("found:", value)
} else {
    fmt.Println("not present")    // key doesn't exist
}
```

Dette er essensielt: tilgang til en manglende nøkkel returnerer verditypen nullverdi (0, "", nil), så du **kan ikke se forskjell** på "nøkkel mangler" fra "nøkkel til stede med nullverdi" bare basert på verdien — `, ok` booleanen avgjør det.

## Iterering (rekkefølge er TILFELDIG)

```go
for key, value := range scores {
    fmt.Println(key, value)
}
// ⚠️ iteration order is RANDOMIZED — never rely on map order!
// To iterate in order: collect keys into a slice, sort it, then iterate.
```

Go randomiserer med vilje iterasjonsrekkefølgen for maps (for å forhindre at kode avhenger av det) — hvis du trenger ordnet iterering, sorterer du nøklene selv.

## nil map-fellen

```go
var m map[string]int        // nil map (declared but not initialized)
v := m["x"]                 // ✅ reading is OK → 0
m["x"] = 1                  // 💥 PANIC: assignment to entry in nil map
// must initialize first: m = make(map[string]int)
```

Et nil map kan leses men **panikk ved skriving** — du må `make()` det (eller bruke en literal) før du lagrer.

## Nøkler må være sammenlignbare

```text
Valid keys: comparable types (string, int, bool, structs of comparable fields, pointers)
Invalid keys: slices, maps, functions (not comparable) → compile error
```

## Hvorfor det er viktig

Maps er en grunnleggende, hyppig brukt Go-datastruktur for nøkkel-verdi-assosiasjoner og rask oppslaging (hurtigbuffere, indekser, telling, gruppering).

Flere oppførsler er essensielle å kjenne og er vanlige feilkilder: **comma-ok idiom** (den eneste pålitelige måten å sjekke nøkkeleksistens på, siden en manglende nøkkel returnerer nullverdien), **randomisert iterasjonsrekkefølge** (bevar deg aldri avhengig av det — sorter nøkler for ordnet utdata), og **nil-map skrivepanikk** (alltid initialisere før skriving).

Å forstå disse — pluss at nøkler må være sammenlignbare typer — er nødvendig for korrekt daglig Go og gjenspeiler den praktiske detaljen som skiller solid Go-utviklere og vises hyppig i intervjuer.