Closures ופונקציות אנונימיות ב-Golang, עם דוגמאות

פונקציות אנונימיות

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

package main

import (
	"fmt"
	"slices"
	"strings"
)

func main() {
	double := func(n int) int { return n * 2 }
	fmt.Println(double(21))

	// Call immediately.
	func(msg string) {
		fmt.Println("now:", msg)
	}("hello")

	// Pass inline as an argument.
	words := []string{"banana", "Apple", "cherry"}
	slices.SortFunc(words, func(a, b string) int {
		return strings.Compare(strings.ToLower(a), strings.ToLower(b))
	})
	fmt.Println(words)
}

ל-Go אין קיצור של חץ או lambda. הצורה המלאה func(params) results { body } היא הדרך היחידה לכתוב פונקציה כזאת.

לכידת משתנים

ליטרל פונקציה יכול להשתמש במשתנים של הפונקציה העוטפת. הוא לא מעתיק אותם: ה-closure והקוד שסביבו חולקים משתנה אחד.

package main

import "fmt"

func main() {
	count := 0
	inc := func() {
		count++
	}

	inc()
	inc()
	fmt.Println(count) // 2: the closure changed the outer variable

	count = 10
	inc()
	fmt.Println(count) // 11: and it sees outside changes too
}

המשתנה הלכוד חי כל עוד closure כלשהו עדיין מתייחס אליו, גם אחרי שהפונקציה שהצהירה עליו חזרה. הקומפיילר מעביר אותו ל-heap כשצריך; אתם אף פעם לא מנהלים את זה בעצמכם.

גנרטורים ומונים

החזרת closure מפונקציה נותנת לכל פונקציה מוחזרת מצב פרטי משלה.

package main

import "fmt"

func counter() func() int {
	n := 0
	return func() int {
		n++
		return n
	}
}

func fibonacci() func() int {
	a, b := 0, 1
	return func() int {
		r := a
		a, b = b, a+b
		return r
	}
}

func main() {
	c1 := counter()
	c2 := counter()
	fmt.Println(c1(), c1(), c1()) // 1 2 3
	fmt.Println(c2())             // 1: separate n

	fib := fibonacci()
	for range 10 {
		fmt.Print(fib(), " ")
	}
	fmt.Println()
}

כל קריאה ל-counter() יוצרת n חדש, ולכן c1 ו-c2 סופרים באופן עצמאי. שום דבר מבחוץ לא יכול לקרוא את n או לאפס אותו, וזו צורה קטנה של כימוס (encapsulation).

Closures בלולאות (Go 1.22 ומעלה)

לפני Go 1.22, ללולאת for היה משתנה לולאה אחד לכל הלולאה. כל ה-closures שנוצרו בתוכה לכדו את אותו משתנה יחיד וראו את הערך הסופי שלו. זה היה באג ה-closures הנפוץ ביותר ב-Go.

החל מ-Go 1.22, כל איטרציה מקבלת עותק משלה, ולכן הקוד הבא מדפיס 0 1 2:

package main

import "fmt"

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()
}

ב-Go 1.21 ומטה, אותה לולאה שנכתבה כ-for i := 0; i < 3; i++ (גם range על מספר שלם הוא חדש ב-1.22) הדפיסה 3 3 3. הכלל החדש חל לפי מודול, על סמך שורת ה-go ב-go.mod, כך שמודול ישן עדיין מקבל את ההתנהגות הישנה עד ששורת ה-go שלו מועלית ל-1.22 ומעלה. עדיין תראו i := i או v := v בתוך לולאות בקוד ישן: זה היה התיקון הידני, ועכשיו הוא מיותר.

הכלל של עותק לכל איטרציה חל רק על משתנים שהוצהרו בהצהרת ה-for עצמה. משתנה שהוצהר לפני הלולאה ומתעדכן בגוף שלה הוא עדיין משתנה משותף אחד:

var last string
for _, s := range items {
	last = s
	handlers = append(handlers, func() { use(last) }) // every closure sees the final value
}

Closures ו-goroutines

goroutine שמופעלת עם ליטרל פונקציה היא גם closure. אותם כללי שיתוף חלים, ועוד כלל המקביליות הרגיל: אם כמה goroutines כותבות למשתנה לכוד, צריך mutex או channel.

package main

import (
	"fmt"
	"sync"
)

func main() {
	var (
		mu    sync.Mutex
		wg    sync.WaitGroup
		total int
	)
	for i := 1; i <= 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mu.Lock()
			total += i
			mu.Unlock()
		}()
	}
	wg.Wait()
	fmt.Println(total)
}

הקוד הזה תמיד מדפיס 5050. כל goroutine קוראת את ה-i שלה (סמנטיקת הלולאות של Go 1.22) וכותבת ל-total המשותף תחת נעילה. הסירו את ה-mutex והתוצאה הופכת לבלתי צפויה; go run -race מדווח על כך כ-data race. ראו goroutines לגבי WaitGroup וה-race detector.

איפה closures מופיעים בקוד אמיתי

• מיון וחיפוש: slices.SortFunc, slices.IndexFunc ו-sort.Slice כולן מקבלות ליטרל פונקציה.
• ניקוי נדחה: defer func() { ... }() מריץ בלוק ביציאה מהפונקציה ויכול לקרוא את המשתנים שלה. ראו defer.
• HTTP middleware: פונקציה שמקבלת handler ומחזירה ליטרל http.HandlerFunc חדש שעוטף אותו.
• קונפיגורציה: functional options (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) הם closures על הארגומנט.

דוגמת middleware שלוכדת גם פרמטר וגם מונה:

package main

import (
	"fmt"
	"strings"
)

type Handler func(string) string

func withLogging(name string, next Handler) Handler {
	calls := 0
	return func(in string) string {
		calls++
		out := next(in)
		fmt.Printf("%s call #%d: %q -> %q\n", name, calls, in, out)
		return out
	}
}

func main() {
	upper := withLogging("upper", strings.ToUpper)
	upper("go")
	upper("closures")
}

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

• לצפות לתמונת מצב. closure קורא את הערך הנוכחי של המשתנה כשהוא רץ, לא את הערך שהיה כשה-closure נוצר. העבירו את הערך כפרמטר אם אתם צריכים תמונת מצב: go func(v int) { ... }(x).
• ליטרלים רקורסיביים. ליטרל פונקציה לא יכול להתייחס לעצמו דרך המשתנה שאליו הוא מושם באותו :=. הצהירו קודם על המשתנה: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• כתיבות לא מסונכרנות מ-goroutines. לכידה היא לא סנכרון. הגנו על כתיבות משותפות.