map ใน Go ทำงานอย่างไร?

Question

Accepted Answer

**map** คือ hash table ที่มีมาให้ในตัวของ Go — เป็นชุดของ **คู่ key-value** ที่ไม่มีลำดับ พร้อมการค้นหาเฉลี่ยที่ O(1) มันเป็นวิธีมาตรฐานในการเชื่อมโยง key กับ value

## การสร้างและใช้งาน map

```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 — แยกแยะ "ไม่มี" ออกจาก "ค่าเป็นศูนย์"

```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 ที่ไม่มีอยู่จะคืน zero value ของชนิด value (0, "", nil) ดังนั้นคุณ **ไม่สามารถบอก** ได้ว่า "key ไม่มีอยู่" ต่างจาก "key มีอยู่แต่ค่าเป็นศูนย์" โดยดูจากค่าเพียงอย่างเดียว — บูลีน `, 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 (เพื่อป้องกันไม่ให้โค้ดพึ่งพาลำดับนั้น) — หากคุณต้องการการวนซ้ำแบบมีลำดับ ให้จัดเรียง key ด้วยตัวเอง

## กับดักของ 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 สามารถอ่านได้ แต่จะ **panic เมื่อเขียน** — คุณต้อง `make()` มัน (หรือใช้ literal) ก่อนจัดเก็บค่า

## key ต้องเปรียบเทียบได้

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

## ทำไมจึงสำคัญ

map เป็นโครงสร้างข้อมูลพื้นฐานของ Go ที่ใช้กันตลอดเวลาสำหรับการเชื่อมโยงแบบ key-value และการค้นหาที่รวดเร็ว (cache, index, การนับ, การจัดกลุ่ม)

มีพฤติกรรมหลายอย่างที่จำเป็นต้องรู้และเป็นแหล่งบั๊กที่พบบ่อย ได้แก่ **สำนวน comma-ok** (วิธีเดียวที่เชื่อถือได้ในการตรวจสอบว่ามี key อยู่หรือไม่ เนื่องจาก key ที่ไม่มีอยู่จะคืน zero value), **ลำดับการวนซ้ำที่ถูกสุ่ม** (อย่าพึ่งพามัน — จัดเรียง key เพื่อให้ได้ผลลัพธ์ที่มีลำดับ) และ **การ panic เมื่อเขียนลง nil map** (ต้องกำหนดค่าเริ่มต้นก่อนเขียนเสมอ)

การเข้าใจสิ่งเหล่านี้ — รวมถึงว่า key ต้องเป็นชนิดที่เปรียบเทียบได้ — เป็นสิ่งจำเป็นสำหรับการเขียน Go ที่ถูกต้องในแต่ละวัน และสะท้อนรายละเอียดเชิงปฏิบัติที่แยกแยะนักพัฒนา Go ที่แน่นจริง และมักปรากฏในการสัมภาษณ์