Golang Closure'lar ve Anonim Fonksiyonlar, Örneklerle

Anonim fonksiyonlar

Fonksiyon literal'i, adı olmayan bir fonksiyondur. Bir ifadedir, bu yüzden bir değerin gidebileceği her yere gidebilir: bir değişkene, bir argümana, bir dönüş değerine, bir struct alanına.

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'da ok ya da lambda kısaltması yoktur. Tam func(params) results { body } biçimi bir tane yazmanın tek yoludur.

Değişken yakalamak

Bir fonksiyon literal'i, çevreleyen fonksiyonun değişkenlerini kullanabilir. Onları kopyalamaz: closure ve çevreleyen kod tek bir değişkeni paylaşır.

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
}

Yakalanan değişken, onu tanımlayan fonksiyon döndükten sonra bile, bir closure ona başvurduğu sürece yaşar. Derleyici gerektiğinde onu heap'e taşır; bunu hiçbir zaman kendiniz yönetmezsiniz.

Üreteçler ve sayaçlar

Bir fonksiyondan bir closure döndürmek, döndürülen her fonksiyona kendi özel durumunu verir.

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()'a yapılan her çağrı yeni bir n oluşturur, bu yüzden c1 ve c2 bağımsız sayar. Dışarıdaki hiçbir şey n'i okuyamaz ya da sıfırlayamaz; bu da bunu küçük bir kapsülleme biçimi yapar.

Döngülerde closure'lar (Go 1.22 ve sonrası)

Go 1.22'den önce bir for döngüsünün tüm döngü için tek bir döngü değişkeni vardı. İçinde oluşturulan closure'ların hepsi o tek değişkeni yakalıyor ve son değerini görüyordu. Bu, Go'daki en yaygın closure hatasıydı.

Go 1.22'den beri her yineleme kendi kopyasını alır, bu yüzden aşağıdaki kod 0 1 2 yazdırır:

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 ve öncesinde for i := 0; i < 3; i++ şeklinde yazılmış aynı döngü (tam sayı üzerinde range de 1.22'de gelen bir yeniliktir) 3 3 3 yazdırıyordu. Yeni kural, go.mod içindeki go satırına göre modül başına uygulanır; bu yüzden eski bir modül, go satırı 1.22 ya da sonrasına yükseltilene kadar eski davranışı alır. Eski kodda döngülerin içinde hâlâ i := i ya da v := v göreceksiniz: bu elle yapılan düzeltmeydi ve artık gereksizdir.

Yineleme başına kural yalnızca for ifadesinin kendisinin tanımladığı değişkenleri kapsar. Döngüden önce tanımlanıp gövdede güncellenen bir değişken hâlâ tek bir paylaşılan değişkendir:

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

Closure'lar ve goroutine'ler

Bir fonksiyon literal'iyle başlatılan goroutine de bir closure'dır. Aynı paylaşım kuralları geçerlidir, artı olağan eşzamanlılık kuralı: birden fazla goroutine yakalanan bir değişkene yazıyorsa bir mutex ya da channel gerekir.

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

Bu her zaman 5050 yazdırır. Her goroutine kendi i'sini okur (Go 1.22 döngü semantiği) ve paylaşılan total'a bir kilit altında yazar. Mutex'i kaldırın, sonuç öngörülemez hale gelir; go run -race bunu bir data race olarak raporlar. WaitGroup ve race detector için goroutine'ler sayfasına bakın.

Closure'ların gerçek kodda görüldüğü yerler

• Sıralama ve arama: slices.SortFunc, slices.IndexFunc, sort.Slice hepsi bir fonksiyon literal'i alır.
• Ertelenmiş temizlik: defer func() { ... }(), fonksiyondan çıkarken bir blok çalıştırır ve fonksiyonun değişkenlerini okuyabilir. defer sayfasına bakın.
• HTTP middleware: bir handler alıp onu saran yeni bir http.HandlerFunc literal'i döndüren bir fonksiyon.
• Yapılandırma: functional options (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }), argüman üzerine kurulmuş closure'lardır.

Hem bir parametreyi hem de bir sayacı yakalayan bir middleware örneği:

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

Sık yapılan hatalar

• Bir anlık görüntü beklemek. Bir closure değişkenin, closure oluşturulduğundaki değerini değil, çalıştığı andaki güncel değerini okur. Anlık görüntü gerekiyorsa değeri parametre olarak aktarın: go func(v int) { ... }(x).
• Özyinelemeli literal'ler. Bir fonksiyon literal'i, aynı := içinde atandığı değişken üzerinden kendine başvuramaz. Önce değişkeni tanımlayın: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Goroutine'lerden senkronize olmayan yazmalar. Yakalamak senkronizasyon değildir. Paylaşılan yazmaları koruyun.