Jak fungují mapy v Go?

Question

Accepted Answer

**Mapa** je vestavěná hashovací tabulka Go — neuspořádaná kolekce **párů klíč-hodnota** s průměrným vyhledáváním O(1). Je to standardní způsob, jak přiřadit klíče hodnotám.

## Vytváření a používání map

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

## Idiom čárka-ok — rozlišování "chybějícího" od "nulového"

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

Toto je základní: přístup k chybějícímu klíči vrací nulovou hodnotu typu hodnoty (0, "", nil), takže **nelze rozlišit** "klíč chybí" od "klíč přítomen s nulovou hodnotou" pouze podle hodnoty — logická hodnota `, ok` je upřesňuje.

## Iterace (pořadí je NÁHODNÉ)

```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 záměrně randomizuje pořadí iterace mapy (aby se zabránilo tomu, aby kód na něj závisel) — pokud potřebujete seřazenou iteraci, seřaďte klíče sami.

## Pasti mapy nil

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

Mapu nil lze číst, ale **se panikos při zápisu** — musíte ji `make()` (nebo použít literál) před uložením.

## Klíče musí být porovnatelné

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

## Proč na to záleží

Mapy jsou základní, neustále používaná datová struktura Go pro přiřazení klíčů k hodnotám a rychlé vyhledávání (mezipaměti, indexy, počítání, seskupování).

Několik chování je nezbytné znát a jsou běžné zdroje chyb: **idiom čárka-ok** (jediný spolehlivý způsob, jak zkontrolovat existenci klíče, protože chybějící klíč vrací nulovou hodnotu), **randomizované pořadí iterace** (nikdy na něm nezávisejte — pro seřazený výstup seřaďte klíče), a **zápis paniky v mapě nil** (před zápisem vždy inicializujte).

Porozumění těmto věcem — plus to, že klíče musí být porovnatelné typy — je nezbytné pro správné každodenní Go a odráží druh praktického detailu, který rozlišuje solidní vývojáře Go a často se objevuje v pohovorech.