ગોમાં maps કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**map** એ Go નું બિલ્ટ-ઇન હેશ ટેબલ છે — **કી-વેલ્યુ જોડીઓ** નો અક્રમબદ્ધ સંગ્રહ O(1) સરેરાશ લુકઅપ સાથે. તે કીને મૂલ્યો સાથે સંકળવાતો પ્રમાણભૂત માર્ગ છે.

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

છે આવશ્યક છે: ગુમ થયેલ કીને access કરવાથી પ્રકારનું શૂન્ય મૂલ્ય મળે છે (0, "", nil), તેથી તમે **કહી શકતા નથી** "કી ગુમ છે" વર્સેસ "કી હાજર શૂન્ય મૂલ્યો સાથે" માત્ર મૂલ્ય દ્વારા — `, ok` બુલિયન સ્પષ્ટતા આપે છે.

## 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 intentionally map પુનરાવર્તન ક્રમને રેન્ડમાઇజ કરે છે (કોડને તેના પર આધારિત થતા અટકાવવા માટે) — જો તમને ક્રમાંકિત પુનરાવર્તનની જરૂર હોય તો કીને પોતે સ્વયંમાં ક્રમમાં ગોઠવો.

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

ઝીણું map વાંચી શકાય છે પરંતુ **લેખન પર પanic કરે છે** — તમે 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 એ મૂળભૂત, સતત વપરાતી Go ડેટા સ્ટ્રક્ચર છે કી-વેલ્યુ સંકળતા અને ઝડપી શોધ માટે (caches, indexes, counting, grouping).

ઘણી આચરણો આવશ્યક છે જાણવી અને સામાન્ય બગ સ્ત્રોતો છે: **comma-ok idiom** (મહત્તમ વિશ્વાસપાત્ર કી અસ્તિત્વ તપાસવાનો માર્ગ, કેમ કે ગુમ થયેલ કી શૂન્ય મૂલ્ય આપે છે), **આપમેળે પુનરાવર્તન ક્રમ** (ક્યારેય તેના પર આધાર રાખશો નહીં — ક્રમાંકિત આઉટપુટ માટે કીને ક્રમમાં ગોઠવો), અને **nil-map લેખન panic** (હંમેશા લેખન કરતા પહેલા પ્રારંભ કરો).

આ સમજવું — જ્યારે કીઓ સરખાવી શકાય તેવા પ્રકારોની હોવી જોઈએ — દૈનંદિન સાચા Go માટે જરૂરી છે અને તે પ્રયોજક વિગતનો પ્રકાર છે જે મજબૂત Go ડેવલપર્સમાં તફાવત રાખે છે અને ઇન્ટરવ્યુમાં વારંવાર દેખાય છે.