Hogyan működnek a maps a Go-ban?

Question

Accepted Answer

A **map** a Go beépített hash táblája — a **kulcs-érték párok** egy rendezetlen gyűjteménye O(1) átlagos keresésekkel. Ez a standard módja annak, hogy kulcsokat értékekhez társítsunk.

## Creating and using 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
```

## The comma-ok idiom — distinguishing "missing" from "zero"

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

Ez lényeges: hiányzó kulcshoz való hozzáférés az érték típusának nulla értékét adja vissza (0, "", nil), így **nem lehet megállapítani** "hiányzó kulcs" vagy "jelen lévő nulla értékű kulcs" csak az érték alapján — a `, ok` logikai érték tisztáz.

## Iterating (order is RANDOM)

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

A Go szándékosan randomizálja a térkép iterálási sorrendjét (hogy megakadályozza a kódnak rá való támaszkodást) — ha rendezett iterációra van szükség, maga rendezze a kulcsokat.

## The nil map trap

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

Egy nil térkép olvasható, de **íráskor pánikol** — `make()`-vel (vagy literál használatával) kell inicializálni az írás előtt.

## Keys must be comparable

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

## Miért fontos ez

A maps alapvető, folyamatosan használt Go adatstruktúra a kulcs-érték asszociációkhoz és gyors keresésekhez (cache-ek, indexek, számlálás, csoportosítás).

Néhány viselkedés alapvető tudnivaló és gyakori hibaforrás: a **comma-ok idiom** (az egyetlen megbízható módja a kulcs létezésének ellenőrzésére, mivel a hiányzó kulcs nulla értéket ad vissza), a **randomizált iterációs sorrend** (soha ne hagyatkozzunk rá — szortírozza a kulcsokat a rendezett kimenethez), és a **nil-map írási pánik** (mindig inicializáljon az írás előtt).

Ennek megértése — plusz a tény, hogy a kulcsoknak összehasonlítható típusoknak kell lenniük — szükséges a helyes mindennapi Go-hoz és azt tükrözi a gyakorlati részletek fajtája, amely megkülönbözteti a szilárd Go fejlesztőket és gyakran megjelenik az interjúkon.