Hur fungerar maps i Go?

Question

Accepted Answer

En **map** är Gos inbyggda hashtabell — en oordnad samling av **nyckel-värde-par** med O(1) genomsnittlig söktid. Det är standardsättet att associera nycklar med värden.

## Skapa och använd 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-idiomatiken — att skilja "saknas" från "noll"

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

Detta är väsentligt: åtkomst av en saknad nyckel returnerar värdetypen nollvärde (0, "", nil), så du **kan inte se** "nyckel saknas" från "nyckel finns med nollvärde" enbart genom värdet — boolean `, ok` gör skilnaden tydlig.

## Iteration (ordning är SLUMPMÄSSIG)

```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 randomiserar avsiktligt iterationsordningen för maps (för att förhindra kod från att förlita sig på den) — om du behöver ordnad iteration, sortera själv nycklarna.

## Nil-map-fällan

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

En nil map kan läsas men **panikerar vid skrivning** — du måste `make()` den (eller använd en literal) innan du lagrar.

## Nycklar måste vara jämförbara

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

## Varför det är viktigt

Maps är en fundamental, ständigt använd Gos datastruktur för nyckel-värde-associationer och snabba sökningar (cachar, index, räkning, gruppering).

Flera beteenden är väsentliga att känna till och är vanliga felkällor: **comma-ok-idiomatiken** (det enda pålitliga sättet att kontrollera nyckelexistens, eftersom en saknad nyckel returnerar nollvärdet), **randomiserad iterationsordning** (förlita dig aldrig på den — sortera nycklar för ordnad utmatning), och **nil-map-skrivpanik** (initiera alltid innan du skriver).

Att förstå dessa — plus att nycklar måste vara jämförbara typer — är nödvändigt för korrekt vardaglig Go och återspeglar den typ av praktisk detalj som skiljer solida Go-utvecklare och förekommer ofta i intervjuer.