Jak działają mapy w Go?

Question

Accepted Answer

**Mapa** to wbudowana tablica mieszająca Go — nieuporządkowana kolekcja **par klucz-wartość** z wyszukiwaniem O(1) średnio. To standardowy sposób kojarzenia kluczy z wartościami.

## Tworzenie i używanie 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 comma-ok — rozróżnianie "brakującego" od "zera"

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

To jest niezbędne: dostęp do brakującego klucza zwraca zerową wartość typu (0, "", nil), więc **nie możesz odróżnić** "klucz nieobecny" od "klucz obecny ze zerową wartością" tylko po wartości — boolean `, ok` to wyjaśnia.

## Iteracja (kolejność jest LOSOWA)

```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 celowo randomizuje kolejność iteracji map (aby uniemożliwić kodowi zależy od tego) — jeśli potrzebujesz iteracji w kolejności, sam posortuj klucze.

## Pułapka 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)
```

Mapę nil można czytać, ale **panika przy zapisie** — przed zapisem musisz ją `make()` (lub użyj literału).

## Klucze muszą być porównywalne

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

## Dlaczego to ważne

Mapy to fundamentalna, stale używana struktura danych Go do kojarzenia klucz-wartość i szybkich wyszukiwań (cache, indeksy, liczenie, grupowanie).

Kilka zachowań jest niezbędnych do zapamiętania i jest częstą źródłem błędów: **idiom comma-ok** (jedyny niezawodny sposób sprawdzenia istnienia klucza, ponieważ brakujący klucz zwraca zerową wartość), **randomizowana kolejność iteracji** (nigdy się na tym nie polegaj — posortuj klucze dla uporządkowanego wyjścia), i **panika zapisu mapy nil** (zawsze inicjalizuj przed zapisem).

Zrozumienie tych — plus fakt, że klucze muszą być porównywalnymi typami — jest konieczne dla poprawnego codziennego Go i odzwierciedla rodzaj szczegółu praktycznego, który odróżnia solidnych programistów Go i często pojawia się na rozmowach kwalifikacyjnych.