Go-வில் maps எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**map** என்பது Go-ன் உள்நிர்மிত hash table — ஒரு வரிசையற்ற **key-value pairs** சேகரணம் O(1) சராசரி lookup-உடன். இது keys-ஐ 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
```

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

இது அপরிहार्य: ஒரு விடுபட்ட key-ஐ அணுகுவது value type-ன் zero value-ஐ (0, "", nil) திருப்பி அளிக்கிறது, எனவே நீங்கள் **சொல்ல முடியாது** "key absent" அல்லது "key present with zero value" 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 செய்யுங்கள்.

## 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-ஐ read செய்ய முடியும் ஆனால் **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 என்பது key-value associations மற்றும் fast lookups (caches, indexes, counting, grouping)-க்கான ஒரு அடிப்படை, தொடர்ந்து பயன்படுத்தப்படும் Go data structure ஆகும்.

பல behaviors அறிந்து கொள்ள முக்கியமாக உள்ளன மற்றும் பொதுவான bug sources ஆக உள்ளன: **comma-ok idiom** (key existence-ஐ சரிபார்ப்பதற்கான ஒரே நம்பகமான வழி, ஒரு விடுபட்ட key zero value-ஐ திருப்பி அளிக்கிறது என்பதிலிருந்து), **randomized iteration order** (எப்போதும் அதைச் சார்ந்திராதீர்கள் — ordered output-க்கு keys-ஐ sort செய்யுங்கள்), மற்றும் **nil-map write panic** (எப்போதும் write செய்வதற்கு முன் initialize செய்யுங்கள்).

இவையைப் புரிந்துகொள்ளுதல் — மேலும் keys-கள் comparable types ஆக இருக்க வேண்டும் என்பது — சரியான தினசரி Go-க்கு அவசியம் மற்றும் திடமான Go developers-ஐ வேறுபடுத்தும் வகையான practical detail-ஐ பிரதிபலிக்கிறது மற்றும் interviews-ல் அடிக்கடி தோன்றுகிறது.

Maps-ஐ உருவாக்குதல் மற்றும் பயன்படுத்துதல்

comma-ok idiom — "missing"-ஐ "zero"-விலிருந்து வேறுபடுத்துதல்

Iterating (order is RANDOM)

nil map trap

Keys-கள் comparable ஆக இருக்க வேண்டும்

ஏன் இது முக்கியமாக உள்ளது

question.related