Map hoạt động như thế nào trong Go?

Question

Accepted Answer

Một **map** là hash table tích hợp sẵn của Go — một tập hợp không có thứ tự các **cặp key-value** với độ phức tạp tra cứu trung bình O(1). Đây là cách chuẩn để liên kết key với value.

## Tạo và sử dụng map

```go
// tạo với make
ages := make(map[string]int)    // map từ key kiểu string tới value kiểu int
ages["Ann"] = 30                 // gán
age := ages["Ann"]               // lấy → 30

// hoặc với một literal
scores := map[string]int{
    "math":    90,
    "science": 85,
}

delete(scores, "math")           // xóa một key
len(scores)                       // số lượng phần tử
```

## Idiom comma-ok — phân biệt "không tồn tại" với "giá trị zero"

```go
// ⚠️ một key không tồn tại trả về GIÁ TRỊ ZERO, không phải error
value := scores["missing"]       // 0 — nhưng nó được lưu là 0, hay không tồn tại? Mơ hồ!

// ✅ dạng comma-ok cho biết key có TỒN TẠI không
value, ok := scores["missing"]
if ok {
    fmt.Println("found:", value)
} else {
    fmt.Println("not present")    // key không tồn tại
}
```

Điều này rất quan trọng: truy cập một key không tồn tại trả về giá trị zero của kiểu value (0, "", nil), nên bạn **không thể phân biệt** "key không tồn tại" với "key tồn tại nhưng mang giá trị zero" chỉ qua giá trị — boolean `, ok` làm rõ điều này.

## Duyệt (thứ tự là NGẪU NHIÊN)

```go
for key, value := range scores {
    fmt.Println(key, value)
}
// ⚠️ thứ tự duyệt là NGẪU NHIÊN — đừng bao giờ dựa vào thứ tự của map!
// Để duyệt theo thứ tự: thu thập key vào một slice, sort nó, rồi duyệt.
```

Go cố tình ngẫu nhiên hóa thứ tự duyệt map (để ngăn code phụ thuộc vào nó) — nếu bạn cần duyệt theo thứ tự, hãy tự sort các key.

## Cạm bẫy nil map

```go
var m map[string]int        // nil map (đã khai báo nhưng chưa khởi tạo)
v := m["x"]                 // ✅ đọc thì OK → 0
m["x"] = 1                  // 💥 PANIC: assignment to entry in nil map
// phải khởi tạo trước: m = make(map[string]int)
```

Một nil map có thể đọc nhưng **panic khi ghi** — bạn phải `make()` nó (hoặc dùng literal) trước khi lưu trữ.

## Key phải có thể so sánh (comparable)

```text
Key hợp lệ: các kiểu comparable (string, int, bool, struct với các trường comparable, con trỏ)
Key không hợp lệ: slice, map, function (không comparable) → lỗi biên dịch
```

## Tại sao điều này quan trọng

Map là một cấu trúc dữ liệu Go nền tảng, được dùng liên tục cho các liên kết key-value và tra cứu nhanh (cache, index, đếm, nhóm).

Một số hành vi rất cần biết và là nguồn lỗi phổ biến: **idiom comma-ok** (cách đáng tin cậy duy nhất để kiểm tra sự tồn tại của key, vì một key không tồn tại trả về giá trị zero), **thứ tự duyệt ngẫu nhiên** (đừng bao giờ phụ thuộc vào nó — sort key để có output theo thứ tự), và **panic khi ghi vào nil map** (luôn khởi tạo trước khi ghi).

Hiểu những điều này — cộng với việc key phải là kiểu comparable — là cần thiết để viết Go đúng đắn hàng ngày và phản ánh kiểu chi tiết thực tế giúp phân biệt các lập trình viên Go vững vàng, đồng thời thường xuất hiện trong phỏng vấn.