Map ב-Golang: יצירה, בדיקת מפתחות, מעבר, מיון ומחיקה

יצירת map ושימוש בו

טיפוס map נכתב map[KeyType]ValueType. צרו אחד עם ליטרל או עם make, ואז קראו, כתבו ומחקו לפי מפתח.

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'])
}

פלט:

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

שתי נוחויות מופיעות כאן. קריאה של מפתח חסר מחזירה את ערך האפס של טיפוס הערך (counts['z'] הוא 0), וזה מה שגורם לספירה עם m[k]++ לעבוד בלי שום הכנה. ו-fmt מדפיס maps עם מפתחות ממוינים, מה שנוח לדיבאג אבל לא אומר כלום על סדר המעבר.

make(map[K]V, n) מקבלת רמז גודל אופציונלי. היא מקצה מראש מקום לבערך n רשומות; בניגוד ל-slices, ל-map אין capacity שאפשר לקרוא בחזרה.

בדיקה אם מפתח קיים: comma-ok

מכיוון שמפתח חסר נקרא כערך האפס, m[k] == 0 לא יכול להבחין בין "לא קיים" ל"שמור כ-0". השתמשו בצורה עם שני הערכים:

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
}

המבנה if v, ok := m[k]; ok { ... } שומר את v ואת ok בתוך ה-scope של ה-if. זו אחת השורות הנפוצות ביותר בקוד Go.

מחיקת רשומות

delete(m, key) מסירה את הרשומה. מחיקה של מפתח שלא קיים לא עושה כלום, וכך גם מחיקה מ-map שהוא nil. כדי לרוקן map שלם, Go 1.21 הוסיפה את clear(m), ששומרת את ה-map שהוקצה כדי שאפשר יהיה להשתמש בו שוב.

מחיקת רשומות בזמן range על אותו map מותרת ובטוחה. רשומה שנמחקה לפני שהלולאה הגיעה אליה לא תופיע.

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))
}

מעבר על map: הסדר אקראי

for k, v := range m מבקרת בכל רשומה פעם אחת, בסדר לא מוגדר. ה-runtime בוחר את נקודת ההתחלה באקראי בכוונה, כך ששתי לולאות על אותו map באותה תוכנית לעיתים קרובות לא מסכימות. הריצו את זה כמה פעמים:

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()
	}
}

כל קוד שהפלט שלו תלוי בסדר של map הוא באג שמחכה להרצה אחרת. בדיקות שמשוות פלט מודפס של מעבר על map הן הדוגמה הקלאסית.

מפתחות ממוינים

כדי לעבור על map לפי סדר המפתחות, קחו את המפתחות, מיינו אותם ופנו ל-map לפיהם. Go 1.23 הפכה את זה לשורה אחת עם iterators מהחבילות maps ו-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 ומטה, maps.Keys לא הייתה קיימת בספרייה הסטנדרטית. המקבילה היא לולאה:

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

עוד פונקציות עזר ב-maps: maps.Values, maps.Clone (העתקה רדודה), maps.Equal, maps.Copy(dst, src) ו-maps.DeleteFunc.

טיפוסי מפתח תקינים

מפתחות חייבים להיות ברי השוואה עם ==: מספרים, מחרוזות, בוליאנים, pointers, channels, מערכים של טיפוסים ברי השוואה, structs שכל השדות שלהם ברי השוואה, וערכי interface. slices, maps ופונקציות לא יכולים להיות מפתחות.

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

מפתח מסוג struct הוא הדרך האידיומטית ליצור מפתח מכמה ערכים בבת אחת, במקום לשרשר מחרוזות.

מפתחות מסוג interface מתקמפלים גם כשהטיפוס הדינמי לא בר השוואה, ואז נכנסים ל-panic בזמן ריצה: שמירה של []int ב-map[any]int נכשלת עם runtime error: hash of unhashable type []int.

מפתחות של נקודה צפה עובדים, אבל NaN לא שווה לעצמו, כך שאפשר להכניס מפתח NaN שוב ושוב ואף פעם לא לקרוא אותו בחזרה. הימנעו ממפתחות float.

map של structs

map יכול להחזיק structs, אבל אי אפשר להשים ערך לשדה של struct ששמור ב-map, כי לערכים של map אין כתובת.

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"])
}

בחרו ערכים כשהרשומות קטנות ומוחלפות בשלמותן. בחרו pointers כשמעדכנים שדות לעיתים קרובות או משתפים את אותה רשומה מכמה מקומות. עם pointers, מפתח חסר מחזיר nil, ולכן ptrs["nope"].Score נכנס ל-panic.

maps של slices עובדים באותה דרך עם append: groups[k] = append(groups[k], v) לא צריך אתחול, כי מפתח חסר נותן slice שהוא nil ו-append מטפלת ב-nil.

maps מתנהגים כמו הפניות

ערך map מפנה לנתונים משותפים. השמה של map או העברה שלו לפונקציה לא מעתיקה את הרשומות: שני המשתנים רואים את אותו 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"])
}

זו הסיבה שפונקציה יכולה למלא map בלי להחזיר אותו, בניגוד ל-slice שהיא מוסיפה אליו.

ה-panic של nil map

ערך האפס של map הוא nil. map שהוא nil נקרא כמו map ריק, אבל כתיבה אליו נכנסת ל-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")
}

פלט:

0 0
recovered: assignment to entry in nil map

המקרה של ה-struct הוא זה שתופס אנשים בפועל. אתחלו שדות map בבנאי (func NewCache() *Cache { return &Cache{data: map[string]string{}} }) או בעצלות, לפני הכתיבה הראשונה.

גישה מקבילית

maps לא בטוחים לשימוש מקבילי. אם goroutine אחת כותבת בזמן שאחרת קוראת או כותבת, ה-runtime עלול לעצור את התוכנית עם fatal error: concurrent map writes (או concurrent map read and map write). זו שגיאה פטאלית, לא panic, ולכן recover לא יכול לתפוס אותה.

הגנו על ה-map עם 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"])
}

זה תמיד מדפיס 50 50. השתמשו ב-sync.RWMutex כשיש הרבה יותר קריאות מכתיבות. sync.Map קיים לשני מקרים צרים (מפתחות שנכתבים פעם אחת ונקראים הרבה פעמים, או goroutines שעובדות על מפתחות נפרדים); לכל השאר mutex ו-map רגיל פשוטים יותר ובדרך כלל מהירים יותר. עוד על זה בעמוד על mutex.

טבלת עזר מהירה

map עם ערכים מסוג struct{} הוא גם טיפוס ה-set של Go; ראו sets.

טעויות נפוצות

• כתיבה ל-map שהוא nil. תמיד צרו אותו עם make, כולל שדות map בתוך structs.
• הסתמכות על סדר המעבר. מיינו את המפתחות.
• שימוש ב-m[k] != 0 כבדיקת קיום. השתמשו ב-comma-ok.
• שינוי שדה של struct דרך m[k].Field. העתיקו החוצה וכתבו בחזרה, או שמרו pointers.
• שיתוף map בין goroutines בלי נעילה. אי אפשר להתאושש מהקריסה.