Cum funcționează mapele în Go?

Question

Accepted Answer

O **hartă** (map) este tabela de dispersie built-in a Go — o colecție neordonată de **perechi cheie-valoare** cu căutare O(1) în medie. Este modalitatea standard de a asocia chei cu valori.

## Crearea și utilizarea mapelor

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

## Idiomul comma-ok — distingerea "lipsit" de "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
}
```

Aceasta este esențială: accesarea unei chei lipsă returnează valoarea zero a tipului (0, "", nil), deci **nu puteți distinge** "cheie absentă" de "cheie prezentă cu valoare zero" doar după valoare — boolean-ul `, ok` clarifică acest lucru.

## Iterare (ordinea este ALEATORIE)

```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 randomizează deliberat ordinea de iterare a mapelor (pentru a preveni ca codul să depindă de aceasta) — dacă aveți nevoie de iterare ordonată, sortați singuri cheile.

## Capcana mapei 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)
```

O hartă nil poate fi citită dar **intră în panică la scriere** — trebuie să o `make()`-ați (sau să folosiți un literal) înainte de a stoca.

## Cheile trebuie să fie comparabile

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

## De ce contează

Mapele sunt o structură de date fundamentală și des utilizată în Go pentru asociații cheie-valoare și căutări rapide (cache, indecși, numărare, grupare).

Citeva comportamente sunt esențiale de cunoscut și sunt surse frecvente de erori: **idiomul comma-ok** (singurul mod fiabil de a verifica existența unei chei, deoarece o cheie lipsă returnează valoarea zero), **ordinea de iterare aleatorie** (nu depindeți niciodată de aceasta — sortați cheile pentru ieșire ordonată), și **panica de scriere a mapei nil** (inițializați întotdeauna înainte de scriere).

Înțelegerea acestora — plus faptul că cheile trebuie să fie tipuri comparabile — este necesară pentru Go corect în fiecare zi și reflectă tipul de detaliu practic care distinge programatorii Go solizi și apare frecvent în interviuri.