Go मध्ये नकाशे कसे कार्य करतात?

Question

Accepted Answer

एक **map** हा Go चा built-in hash table आहे — **key-value जोडी** यांचा अनियोजित संग्रह O(1) सरासरी lookup सह. हा keys चा values शी संबंध जोडण्याचा मानक मार्ग आहे.

## नकाशे तयार करणे आणि वापरणे

```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 — "गायब" आणि "शून्य" मध्ये फरक करणे

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

हे आवश्यक आहे: गायब key मध्ये प्रवेश करण्याने value type चे शून्य मूल्य (0, "", nil) परत मिळते, तर आपण केवळ मूल्यापासून "key अनुपस्थित" आणि "key present with zero value" मध्ये फरक **करू शकत नाही** — `, ok` बूलियन हा स्पष्ट करते.

## पुनरावृत्ती (क्रम यादृच्छिक आहे)

```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 क्रम यादृच्छिक करते (कोड याच्यावर अवलंबून राहण्यास रोखण्यासाठी) — जर आपल्याला क्रमबद्ध पुनरावृत्तीची आवश्यकता असल्यास, आपले keys स्वतः sort करा.

## nil map जाळा

```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 वाचले जाऊ शकते परंतु **लिहिण्यावर बिघडते** — आपल्याला store करण्यापूर्वी `make()` करणे आवश्यक आहे (किंवा literal वापरा).

## Keys तुलनीय असणे आवश्यक आहे

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

## हे का महत्वाचे आहे

नकाशे हे Go चे मूलभूत, सतत वापरलेले data structure आहेत key-value associations आणि fast lookups (caches, indexes, counting, grouping) साठी.

अनेक वर्तन ज्ञात असणे आवश्यक आहे आणि ते सामान्य bug sources आहेत: **कोमा-ओके idiom** (key existence तपासण्याचा एकमेव विश्वसनीय मार्ग, कारण गायब key शून्य मूल्य परत करते), **यादृच्छिक पुनरावृत्ती क्रम** (यावर कधीही अवलंबून राहू नका — ordered output साठी keys sort करा), आणि **nil-map write panic** (लिहिण्यापूर्वी नेहमी initialize करा).

यांची समज — अतिरिक्त की keys तुलनीय types असण्याचे की — दैनंदिन सुयोग्य Go साठी आवश्यक आहे आणि प्रयोगात्मक विस्तार प्रतिबिंबित करते जो solid Go developers वेगळे करते आणि interview मध्ये वारंवार दिसते.