Go ਵਿੱਚ maps ਕਿਵੇਂ ਕਾਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇੱਕ **map** Go ਦੀ built-in hash table ਹੈ — ਇੱਕ unordered ਸੰਗ੍ਰਹਿ **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 disambiguate ਕਰਦਾ ਹੈ।

## 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 ਕਰਦਾ ਹੈ (ਕੋਡ ਨੂੰ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਹੋਣ ਤੋਂ ਰੋਕਣ ਲਈ) — ਜੇ ਤੁਹਾਨੂੰ 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 ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ — correct everyday Go ਲਈ ਜਰੂਰੀ ਹੈ ਅਤੇ ਉਸ practical detail ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ solid Go developers ਨੂੰ ਛਾਂਟਦਾ ਹੈ ਅਤੇ frequently interviews ਵਿੱਚ ਆਉਂਦਾ ਹੈ।