الإغلاقات والدوال المجهولة في Golang مع أمثلة

الدوال المجهولة

الدالة الحرفية (function literal) دالة بلا اسم. وهي تعبير، لذا تُكتب في أي مكان تُكتب فيه قيمة: متغيّر، أو وسيط، أو قيمة معادة، أو حقل في بنية.

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 } هو الطريقة الوحيدة لكتابتها.

التقاط المتغيّرات

تستطيع الدالة الحرفية استخدام متغيّرات الدالة المحيطة بها. وهي لا تنسخها: الإغلاق والشيفرة المحيطة يتشاركان متغيّرًا واحدًا.

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
}

يعيش المتغيّر الملتقط ما دام إغلاق ما يشير إليه، حتى بعد عودة الدالة التي عرّفته. ينقله المترجم إلى الكومة (heap) عند الحاجة؛ ولا تدير ذلك بنفسك أبدًا.

المولّدات والعدّادات

إعادة إغلاق من دالة تمنح كل دالة معادة حالتها الخاصة.

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 أو إعادة ضبطه، وهذا شكل صغير من التغليف.

الإغلاقات في الحلقات (Go 1.22 وما بعده)

قبل Go 1.22 كان لحلقة for متغيّر حلقة واحد للحلقة كلها. الإغلاقات المنشأة داخلها كانت كلها تلتقط هذا المتغيّر الوحيد وترى قيمته الأخيرة. كان هذا أشيع خطأ في الإغلاقات في 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
}

الإغلاقات والـ goroutines

الـ goroutine التي تبدأ بدالة حرفية هي إغلاق أيضًا. تنطبق قواعد المشاركة نفسها، إضافة إلى قاعدة التزامن المعتادة: إذا كتبت عدة goroutines في متغيّر ملتقط، فأنت تحتاج إلى mutex أو قناة.

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 على أنها سباق بيانات. راجع الـ goroutines لمعرفة WaitGroup وكاشف السباقات.

أين تظهر الإغلاقات في الشيفرة الحقيقية

• الترتيب والبحث: كل من slices.SortFunc وslices.IndexFunc وsort.Slice تأخذ دالة حرفية.
• التنظيف المؤجّل: defer func() { ... }() تنفّذ كتلة عند خروج الدالة ويمكنها قراءة متغيّرات الدالة. راجع defer.
• الطبقات الوسيطة في HTTP: دالة تأخذ معالجًا وتعيد دالة حرفية جديدة من النوع http.HandlerFunc تغلّفه.
• الإعداد: الخيارات الوظيفية (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) إغلاقات على الوسيط.

مثال طبقة وسيطة تلتقط معاملًا وعدّادًا معًا:

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

أخطاء شائعة

• توقّع لقطة ثابتة. يقرأ الإغلاق القيمة الحالية للمتغيّر عند تنفيذه، لا القيمة وقت إنشائه. مرّر القيمة معاملًا إذا احتجت لقطة: go func(v int) { ... }(x).
• الدوال الحرفية العودية. لا تستطيع الدالة الحرفية الإشارة إلى نفسها عبر المتغيّر الذي تُسند إليه في عبارة := نفسها. عرّف المتغيّر أولًا: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• كتابات غير متزامنة من goroutines. الالتقاط ليس تزامنًا. احمِ الكتابات المشتركة.