Closure dan Fungsi Anonim di Golang, dengan Contoh

Fungsi anonim

Function literal adalah fungsi tanpa nama. Function literal adalah ekspresi, jadi bisa ditaruh di mana pun sebuah nilai bisa ditaruh: variabel, argumen, nilai kembalian, field 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 tidak punya penulisan singkat berupa arrow atau lambda. Bentuk lengkap func(params) results { body } adalah satu-satunya cara menulisnya.

Menangkap variabel

Function literal bisa memakai variabel dari fungsi yang melingkupinya. Variabel itu tidak disalin: closure dan kode di sekitarnya memakai satu variabel yang sama.

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
}

Variabel yang ditangkap tetap hidup selama masih ada closure yang merujuknya, bahkan setelah fungsi yang mendeklarasikannya sudah selesai. Compiler memindahkannya ke heap kalau perlu; kamu tidak pernah mengurus hal itu sendiri.

Generator dan counter

Mengembalikan closure dari sebuah fungsi memberi setiap fungsi yang dikembalikan state pribadinya sendiri.

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

Setiap pemanggilan counter() membuat n yang baru, jadi c1 dan c2 menghitung secara terpisah. Tidak ada kode di luar yang bisa membaca atau mereset n, sehingga ini menjadi bentuk kecil dari enkapsulasi.

Closure di dalam loop (Go 1.22 dan sesudahnya)

Sebelum Go 1.22, for loop hanya punya satu variabel loop untuk seluruh loop. Semua closure yang dibuat di dalamnya menangkap variabel tunggal itu dan melihat nilai terakhirnya. Itulah bug closure yang paling umum di Go.

Sejak Go 1.22, setiap iterasi mendapat salinannya sendiri, jadi kode di bawah ini mencetak 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()
}

Di Go 1.21 dan sebelumnya, loop yang sama yang ditulis sebagai for i := 0; i < 3; i++ (range atas integer juga baru ada di 1.22) mencetak 3 3 3. Aturan baru ini berlaku per modul, berdasarkan baris go di go.mod, jadi modul lama tetap memakai perilaku lama sampai baris go-nya dinaikkan ke 1.22 atau lebih baru. Kamu masih akan melihat i := i atau v := v di dalam loop pada kode lama: itu perbaikan manual dan sekarang sudah tidak diperlukan.

Aturan per iterasi hanya berlaku untuk variabel yang dideklarasikan oleh pernyataan for itu sendiri. Variabel yang dideklarasikan sebelum loop dan diubah di dalam badan loop tetap satu variabel bersama:

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

Closure dan goroutine

Goroutine yang dijalankan dengan function literal juga merupakan closure. Aturan berbagi yang sama berlaku, ditambah aturan konkurensi yang biasa: kalau beberapa goroutine menulis ke variabel yang ditangkap, kamu butuh mutex atau 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)
}

Kode ini selalu mencetak 5050. Setiap goroutine membaca i miliknya sendiri (semantik loop Go 1.22) dan menulis ke total bersama di bawah lock. Hapus mutex-nya dan hasilnya jadi tidak bisa ditebak; go run -race melaporkannya sebagai data race. Lihat goroutine untuk WaitGroup dan race detector.

Di mana closure muncul di kode sungguhan

• Pengurutan dan pencarian: slices.SortFunc, slices.IndexFunc, sort.Slice semuanya menerima function literal.
• Pembersihan yang ditunda: defer func() { ... }() menjalankan sebuah blok saat fungsi selesai dan bisa membaca variabel fungsi itu. Lihat defer.
• Middleware HTTP: fungsi yang menerima handler lalu mengembalikan literal http.HandlerFunc baru yang membungkusnya.
• Konfigurasi: functional options (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) adalah closure atas argumennya.

Contoh middleware yang menangkap parameter sekaligus counter:

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

Kesalahan umum

• Mengharapkan potret nilai. Closure membaca nilai variabel saat closure itu berjalan, bukan nilai saat closure dibuat. Kirim nilainya sebagai parameter kalau kamu butuh potret: go func(v int) { ... }(x).
• Literal rekursif. Function literal tidak bisa merujuk dirinya sendiri lewat variabel yang sedang di-assign kepadanya dalam := yang sama. Deklarasikan variabelnya lebih dulu: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Penulisan dari goroutine tanpa sinkronisasi. Menangkap variabel bukanlah sinkronisasi. Lindungi penulisan ke data bersama.