Go में maps कैसे काम करते हैं?

Question

Accepted Answer

एक **map** Go का built-in hash table है — **key-value pairs** का एक unordered collection जिसमें O(1) average lookup है। यह keys को values के साथ जोड़ने का standard तरीका है।

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

यह आवश्यक है: एक missing key को access करने से value type का zero value (0, "", nil) return होता है, इसलिए आप **नहीं बता सकते** कि "key absent" है या "key present with zero value" — केवल `, ok` boolean disambiguate करता है।

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

Go deliberately map iteration order को randomize करता है (code को इस पर निर्भर होने से रोकने के लिए) — अगर आपको ordered iteration की ज़रूरत है, तो keys को खुद sort करें।

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

एक nil map को read किया जा सकता है लेकिन **write पर panic करता है** — आपको store करने से पहले इसे `make()` करना चाहिए (या literal का उपयोग करें)।

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

## यह क्यों महत्वपूर्ण है

Maps एक fundamental, constantly-used Go data structure हैं key-value associations और fast lookups के लिए (caches, indexes, counting, grouping)।

कई behaviors को जानना essential है और ये common bug sources हैं: **comma-ok idiom** (key existence check करने का एकमात्र reliable तरीका, क्योंकि एक missing key zero value return करता है), **randomized iteration order** (कभी इस पर निर्भर न रहें — ordered output के लिए keys sort करें), और **nil-map write panic** (हमेशा write करने से पहले initialize करें)।

इन्हें समझना — साथ ही यह कि keys comparable types होने चाहिए — सही, रोज़मर्रा के Go के लिए ज़रूरी है और practical detail का प्रकार दर्शाता है जो solid Go developers को अलग करता है और अक्सर interviews में दिखाई देता है।