Go లో maps ఎలా కెళ్లాయి?

Question

Accepted Answer

A **map** is Go's built-in hash table — an unordered collection of **key-value pairs** with O(1) average lookup. It's the standard way to associate keys with values.

## 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) ను వापిస్తుంది, కాబట్టి మీరు **చెప్పలేరు** "key absent" లేదా "key present with zero value" ఉందో కాదో విలువ ద్వారా మాత్రమే — `, ok` boolean ఇది సపష్టం చేస్తుంది.

## 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 ఉద్దేశపూర్వకంగా 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)
```

A nil map ని read చేయవచ్చు కానీ **write చేస్తే panic అవుతుంది** — సంచయం చేయడానికి ముందు మీరు `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 అనేది key-value associations మరియు fast lookups (caches, indexes, counting, grouping) కోసం ఒక fundamental, constantly-used Go data structure.

చాలా behaviors ను తెలుసుకోవడం అవసరం మరియు అవి సాధారణ bug sources: the **comma-ok idiom** (key existence ని check చేయడానికి ఏకైక నమ్మదగిన మార్గం, ఎందుకంటే missing key zero value ను వాపిస్తుంది), the **randomized iteration order** (దానిపై ఆధారపడవద్దు — ordered output కోసం keys ని sort చేయండి), మరియు the **nil-map write panic** (writing ముందు ఎప్పుడూ initialize చేయండి).

ఇవి అర్థం చేసుకోవడం — plus keys తప్పనిసరిగా comparable types ఉండాలి — correct everyday Go కోసం అవసరం మరియు ఇది practical detail ని ప్రతిబింబిస్తుంది, ఇది solid Go developers ను వేరు చేస్తుంది మరియు interviews లో తరచుగా కనిపిస్తుంది.