Closure và hàm ẩn danh trong Golang, kèm ví dụ

Hàm ẩn danh

Function literal là một hàm không có tên. Nó là một biểu thức, nên có thể đặt ở bất cứ đâu một giá trị đặt được: một biến, một đối số, một giá trị trả về, một trường của 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 không có cú pháp viết tắt kiểu mũi tên hay lambda. Dạng đầy đủ func(params) results { body } là cách duy nhất để viết hàm ẩn danh (anonymous function).

Giữ lại biến

Một function literal có thể dùng các biến của hàm bao quanh. Nó không sao chép chúng: closure và code xung quanh dùng chung một biến.

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
}

Biến được giữ lại sống chừng nào còn closure tham chiếu tới nó, kể cả sau khi hàm khai báo ra nó đã trả về. Trình biên dịch chuyển nó lên heap khi cần; bạn không bao giờ phải tự quản lý việc đó.

Generator và bộ đếm

Trả về một closure từ một hàm sẽ cho mỗi hàm được trả về một trạng thái riêng.

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

Mỗi lần gọi counter() tạo ra một n mới, nên c1 và c2 đếm độc lập. Không gì bên ngoài đọc hay đặt lại được n, nên đây là một dạng đóng gói nhỏ.

Closure trong vòng lặp (Go 1.22 trở lên)

Trước Go 1.22, một vòng lặp for chỉ có một biến vòng lặp cho cả vòng lặp. Các closure tạo bên trong đều giữ lại đúng một biến đó và thấy giá trị cuối cùng của nó. Đây là lỗi closure phổ biến nhất trong Go.

Từ Go 1.22, mỗi lần lặp có bản sao riêng, nên đoạn code dưới đây in ra 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()
}

Với Go 1.21 trở về trước, cùng vòng lặp đó viết dưới dạng for i := 0; i < 3; i++ (range trên một số nguyên cũng mới có từ 1.22) in ra 3 3 3. Quy tắc mới áp dụng theo từng module, dựa trên dòng go trong go.mod, nên một module cũ vẫn giữ hành vi cũ cho đến khi dòng go của nó được nâng lên 1.22 trở lên. Bạn vẫn sẽ thấy i := i hay v := v bên trong vòng lặp ở code cũ: đó là cách sửa thủ công và giờ đã thừa.

Quy tắc theo từng lần lặp chỉ áp dụng cho các biến do chính câu lệnh for khai báo. Một biến khai báo trước vòng lặp và được cập nhật trong thân vẫn là một biến dùng chung:

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

Closure và goroutine

Một goroutine khởi chạy bằng function literal cũng là một closure. Các quy tắc dùng chung vẫn áp dụng, cộng thêm quy tắc quen thuộc về đồng thời: nếu nhiều goroutine cùng ghi vào một biến được giữ lại, bạn cần mutex hoặc 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)
}

Đoạn code này luôn in ra 5050. Mỗi goroutine đọc i của riêng nó (theo ngữ nghĩa vòng lặp của Go 1.22) và ghi vào total dùng chung trong khi giữ khóa. Bỏ mutex đi thì kết quả trở nên khó đoán; go run -race báo đó là một data race. Xem goroutines về WaitGroup và race detector.

Closure xuất hiện ở đâu trong code thực tế

• Sắp xếp và tìm kiếm: slices.SortFunc, slices.IndexFunc, sort.Slice đều nhận một function literal.
• Dọn dẹp trì hoãn: defer func() { ... }() chạy một khối lệnh khi hàm kết thúc và đọc được các biến của hàm. Xem defer.
• HTTP middleware: một hàm nhận một handler và trả về một literal http.HandlerFunc mới bọc quanh handler đó.
• Cấu hình: functional option (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) là closure giữ lại đối số.

Một ví dụ middleware giữ lại cả một tham số lẫn một bộ đếm:

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

Lỗi thường gặp

• Tưởng closure chụp lại giá trị. Closure đọc giá trị hiện tại của biến lúc nó chạy, không phải giá trị lúc closure được tạo. Hãy truyền giá trị làm tham số nếu bạn cần một bản chụp: go func(v int) { ... }(x).
• Literal đệ quy. Một function literal không thể tự gọi mình qua biến mà nó đang được gán vào trong cùng một :=. Hãy khai báo biến trước: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Ghi không đồng bộ từ các goroutine. Giữ lại biến không phải là đồng bộ. Hãy bảo vệ các lần ghi dùng chung.