Go मा maps कसरी काम गर्छन्?

Question

Accepted Answer

एक **map** Go को built-in hash table हो — एक unordered collection को **key-value pairs** को साथ O(1) average lookup। यो keys लाई values सँग associate गर्ने standard तरिका हो।

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

## comma-ok idiom — "missing" र "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), त्यसैले तपाई **बताउन सक्नुहुन्न** "key absent" वा "key present with zero value" मान मात्रै द्वारा — `, ok` boolean disambiguates गर्छ।

## Iterating (order 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 जानबूझी map iteration order लाई randomize गर्छ (code लाई यसमा निर्भर हुन रोक्न) — यदि तपाईलाई ordered iteration चाहिन्छ, आफैले keys लाई sort गर्नुहोस्।

## 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 लाई पढ्न सकिन्छ तर **write मा panics हुन्छ** — तपाईले store गर्न अगि `make()` गर्नुपर्छ (वा एक literal प्रयोग गर्नुहोस्)।

## Keys अवश्य 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 आवश्यक छन् र common bug sources हुन्: **comma-ok idiom** (key existence जाँच गर्ने एकमात्र reliable तरिका, किनभने एक missing key ले zero value फर्काउँछ), **randomized iteration order** (कहिल्यै यसमा निर्भर नगर्नुहोस् — ordered output को लागि keys लाई sort गर्नुहोस्), र **nil-map write panic** (write गर्न अगि सधैं initialize गर्नुहोस्)।

यी बुझ्न — साथै keys अवश्य comparable types हुनुपर्छ — सही everyday Go को लागि आवश्यक छ र solid Go developers लाई छुट्याउने practical detail प्रतिबिम्बित गर्छ र frequently interviews मा देखा पर्छ।