Map trong Golang: tạo, kiểm tra khóa, duyệt, sắp xếp và xóa

Tạo và dùng map

Kiểu map được viết là map[KeyType]ValueType. Tạo map bằng literal hoặc bằng make, rồi đọc, ghi và xóa theo khóa.

package main

import "fmt"

func main() {
	ages := map[string]int{
		"ana": 31,
		"bob": 25,
	}

	ages["cy"] = 40          // insert
	ages["bob"] = 26         // update
	fmt.Println(ages["ana"]) // read
	fmt.Println(len(ages))   // number of entries

	delete(ages, "ana")
	fmt.Println(ages) // fmt prints maps with keys sorted

	counts := make(map[rune]int)
	for _, r := range "hello" {
		counts[r]++ // missing keys start at zero
	}
	fmt.Println(counts['l'], counts['z'])
}

Đầu ra:

31
3
map[bob:26 cy:40]
2 0

Ví dụ trên có hai điểm tiện lợi. Đọc một khóa không tồn tại trả về giá trị zero của kiểu giá trị (counts['z'] là 0), nên đếm bằng m[k]++ chạy được mà không cần chuẩn bị gì. Và fmt in map với các khóa đã sắp xếp, rất tiện khi gỡ lỗi nhưng không nói lên gì về thứ tự duyệt.

make(map[K]V, n) nhận thêm một gợi ý kích thước (không bắt buộc). Nó cấp phát trước chỗ cho khoảng n phần tử; khác với slice, map không có dung lượng (capacity) để bạn đọc lại.

Kiểm tra khóa có tồn tại: comma-ok

Vì khóa không tồn tại được đọc ra là giá trị zero, m[k] == 0 không phân biệt được "không có" với "đang lưu 0". Hãy dùng dạng trả về hai giá trị:

package main

import "fmt"

func main() {
	stock := map[string]int{"apple": 0, "pear": 12}

	if n, ok := stock["apple"]; ok {
		fmt.Println("apple is listed, quantity", n)
	}

	if _, ok := stock["kiwi"]; !ok {
		fmt.Println("kiwi is not listed")
	}

	fmt.Println(stock["apple"] == stock["kiwi"]) // both 0: indistinguishable without ok
}

Cấu trúc if v, ok := m[k]; ok { ... } giữ v và ok trong phạm vi của câu lệnh if. Đây là một trong những dòng code phổ biến nhất trong Go.

Xóa phần tử

delete(m, key) xóa phần tử tương ứng. Xóa một khóa không tồn tại sẽ không làm gì cả, xóa trên map nil cũng vậy. Để làm rỗng cả map, Go 1.21 bổ sung clear(m), hàm này giữ lại vùng nhớ đã cấp phát để map được dùng lại.

Xóa phần tử trong lúc range trên chính map đó là được phép và an toàn. Phần tử bị xóa trước khi vòng lặp đi tới sẽ không xuất hiện nữa.

package main

import "fmt"

func main() {
	sessions := map[string]int{"a": 5, "b": 120, "c": 90, "d": 3}
	for id, idle := range sessions {
		if idle > 60 {
			delete(sessions, id) // safe during range
		}
	}
	fmt.Println(sessions)

	clear(sessions)
	fmt.Println(len(sessions))
}

Duyệt map: thứ tự là ngẫu nhiên

for k, v := range m đi qua mỗi phần tử đúng một lần, theo thứ tự không xác định. Runtime cố ý chọn ngẫu nhiên điểm bắt đầu, nên hai vòng lặp trên cùng một map trong cùng chương trình thường cho thứ tự khác nhau. Hãy chạy đoạn này vài lần:

package main

import "fmt"

func main() {
	m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
	for range 3 {
		for k := range m {
			fmt.Print(k, " ")
		}
		fmt.Println()
	}
}

Mọi đoạn code có đầu ra phụ thuộc vào thứ tự của map đều là bug đang chờ một lần chạy khác. Test so sánh kết quả in ra khi duyệt map là ví dụ kinh điển.

Sắp xếp khóa

Để duyệt map theo thứ tự khóa, hãy lấy các khóa, sắp xếp chúng rồi truy cập map theo từng khóa. Go 1.23 biến việc này thành một dòng nhờ các iterator của package maps và slices:

package main

import (
	"cmp"
	"fmt"
	"maps"
	"slices"
)

func main() {
	prices := map[string]float64{"tea": 2.5, "coffee": 3.2, "juice": 4.0, "water": 1.0}

	for _, k := range slices.Sorted(maps.Keys(prices)) {
		fmt.Printf("%-7s %.2f\n", k, prices[k])
	}

	keys := slices.Collect(maps.Keys(prices)) // unsorted slice of keys
	fmt.Println(len(keys))

	// Sort by value instead: sort the keys with a custom comparison.
	byPrice := slices.Collect(maps.Keys(prices))
	slices.SortFunc(byPrice, func(a, b string) int {
		return cmp.Compare(prices[a], prices[b])
	})
	fmt.Println(byPrice)
}

Ở Go 1.22 trở về trước, thư viện chuẩn chưa có maps.Keys. Cách làm tương đương là một vòng lặp:

keys := make([]string, 0, len(m))
for k := range m {
	keys = append(keys, k)
}
sort.Strings(keys)

Các hàm hỗ trợ khác trong maps: maps.Values, maps.Clone (bản sao nông), maps.Equal, maps.Copy(dst, src) và maps.DeleteFunc.

Kiểu khóa hợp lệ

Khóa phải so sánh được bằng ==: số, chuỗi, boolean, con trỏ, channel, mảng gồm các kiểu so sánh được, struct có mọi trường đều so sánh được, và giá trị interface. Slice, map và hàm không thể làm khóa.

map[[]int]bool{}       // compile error: invalid map key type []int
map[[2]int]bool{}      // fine: arrays are comparable
map[struct{ X, Y int }]string{} // fine: a struct key for a grid position

Dùng struct làm khóa là cách viết chuẩn của Go khi cần khóa theo nhiều giá trị cùng lúc, thay vì nối chuỗi.

Khóa kiểu interface vẫn biên dịch được kể cả khi kiểu động không so sánh được, rồi panic lúc chạy: lưu một []int vào map[any]int sẽ thất bại với runtime error: hash of unhashable type []int.

Khóa số thực vẫn dùng được, nhưng NaN không bằng chính nó, nên một khóa NaN có thể được thêm vào nhiều lần mà không bao giờ đọc lại được. Hãy tránh dùng khóa số thực.

Map chứa struct

Map có thể chứa struct, nhưng bạn không thể gán cho một trường của struct đang nằm trong map, vì giá trị trong map không lấy địa chỉ được.

package main

import "fmt"

type User struct {
	Name  string
	Score int
}

func main() {
	users := map[string]User{"u1": {Name: "Ana"}}
	// users["u1"].Score = 10 // compile error: cannot assign to struct field users["u1"].Score in map

	u := users["u1"] // copy out
	u.Score = 10
	users["u1"] = u // write back
	fmt.Println(users["u1"])

	// Or store pointers, and modify in place.
	ptrs := map[string]*User{"u2": {Name: "Bob"}}
	ptrs["u2"].Score += 5
	fmt.Println(*ptrs["u2"])
}

Chọn lưu giá trị khi phần tử nhỏ và được thay thế nguyên khối. Chọn lưu con trỏ khi bạn cập nhật trường thường xuyên hoặc dùng chung một bản ghi từ nhiều nơi. Với con trỏ, khóa không tồn tại trả về nil, nên ptrs["nope"].Score sẽ panic.

Map chứa slice cũng vậy khi append: groups[k] = append(groups[k], v) không cần khởi tạo, vì khóa không tồn tại cho ra một slice nil và append xử lý được nil.

Map hoạt động giống tham chiếu

Một giá trị map trỏ tới dữ liệu dùng chung. Gán map hoặc truyền map vào hàm không sao chép các phần tử: cả hai biến cùng nhìn thấy một map.

package main

import (
	"fmt"
	"maps"
)

func addDefault(m map[string]int) {
	m["default"] = 1 // visible to the caller
}

func main() {
	a := map[string]int{"x": 1}
	b := a
	b["y"] = 2
	addDefault(a)
	fmt.Println(a)

	c := maps.Clone(a) // independent shallow copy
	c["x"] = 100
	fmt.Println(a["x"], c["x"])
}

Đó là lý do một hàm có thể điền dữ liệu vào map mà không cần trả map về, khác với một slice mà hàm append vào.

Panic khi dùng map nil

Giá trị zero của map là nil. Map nil đọc giống như map rỗng, nhưng ghi vào thì panic.

package main

import "fmt"

type Cache struct {
	data map[string]string
}

func main() {
	var m map[string]int
	fmt.Println(m["x"], len(m)) // reading nil is fine

	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var c Cache       // data is nil
	c.data["k"] = "v" // panics
	fmt.Println("not reached")
}

Đầu ra:

0 0
recovered: assignment to entry in nil map

Trường hợp map nằm trong struct mới là trường hợp hay gây lỗi trong thực tế. Hãy khởi tạo các trường map trong hàm khởi tạo (func NewCache() *Cache { return &Cache{data: map[string]string{}} }) hoặc khởi tạo trễ ngay trước lần ghi đầu tiên.

Truy cập đồng thời

Map không an toàn khi dùng đồng thời. Nếu một goroutine ghi trong khi goroutine khác đọc hoặc ghi, runtime có thể dừng chương trình với fatal error: concurrent map writes (hoặc concurrent map read and map write). Đây là fatal error, không phải panic, nên recover không bắt được.

Hãy bảo vệ map bằng một mutex:

package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	mu sync.Mutex
	m  map[string]int
}

func (c *Counter) Inc(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.m[key]++
}

func main() {
	c := Counter{m: make(map[string]int)}
	var wg sync.WaitGroup
	for i := range 100 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			c.Inc([]string{"red", "green"}[i%2])
		}()
	}
	wg.Wait()
	fmt.Println(c.m["red"], c.m["green"])
}

Chương trình này luôn in ra 50 50. Dùng sync.RWMutex khi số lần đọc nhiều hơn hẳn số lần ghi. sync.Map chỉ dành cho hai trường hợp hẹp (khóa được ghi một lần và đọc nhiều lần, hoặc các goroutine làm việc trên những khóa tách biệt); với mọi trường hợp còn lại, một mutex cùng một map thường đơn giản hơn và thường nhanh hơn. Xem thêm ở mutex.

Tra cứu nhanh

Một map có giá trị struct{} cũng chính là kiểu tập hợp (set) của Go; xem set.

Lỗi thường gặp

• Ghi vào map nil. Luôn tạo map bằng make, kể cả các trường map trong struct.
• Dựa vào thứ tự duyệt. Hãy sắp xếp các khóa.
• Dùng m[k] != 0 để kiểm tra tồn tại. Hãy dùng comma-ok.
• Sửa trường của struct qua m[k].Field. Sao chép ra rồi ghi lại, hoặc lưu con trỏ.
• Dùng chung map giữa các goroutine mà không khóa. Lỗi sập chương trình không thể recover.