Closure hoạt động như thế nào trong Go?

Question

Accepted Answer

Một **closure** là một hàm tham chiếu đến các biến từ phạm vi bao quanh của nó, "đóng kín (closing over)" chúng — hàm giữ quyền truy cập vào các biến đó ngay cả sau khi hàm bao quanh đã trả về. Hàm trong Go là các giá trị first-class, khiến closure trở thành một công cụ phổ biến và mạnh mẽ.

## Một closure cơ bản

```go
func makeCounter() func() int {
    count := 0                  // một biến cục bộ
    return func() int {          // hàm bên trong này ĐÓNG KÍN count
        count++                  // nó có thể đọc VÀ sửa đổi count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count GIỮ LẠI giữa các lần gọi (trạng thái được giữ)

other := makeCounter()    // một closure MỚI, độc lập với count riêng của nó
fmt.Println(other())     // 1 — trạng thái riêng biệt
```

Hàm được trả về giữ một tham chiếu tới `count` ngay cả sau khi `makeCounter` trả về — nên trạng thái được giữ qua các lần gọi. Mỗi lần gọi `makeCounter` tạo một `count` mới, độc lập. Đây là trạng thái riêng tư được đóng gói.

## Closure bắt biến theo THAM CHIẾU (điểm then chốt)

```go
// closure bắt chính biến đó, không phải một ảnh chụp giá trị của nó
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — thấy giá trị HIỆN TẠI của x, không phải 10
```

## Cạm bẫy biến vòng lặp kinh điển

```go
// ⚠️ trong các phiên bản Go TRƯỚC 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // tất cả đóng kín CÙNG một i
}
for _, f := range funcs { f() }   // in 3, 3, 3 (không phải 0, 1, 2)! — tất cả chung i

// cách sửa kinh điển (trước 1.22): tạo một bản sao mỗi vòng lặp
for i := 0; i < 3; i++ {
    i := i                          // che bằng một biến mới mỗi vòng lặp
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Lưu ý: Go 1.22+ đã thay đổi ngữ nghĩa vòng lặp để mỗi vòng có một biến MỚI — lỗi này đã được sửa.
```

Đây là một lỗi nổi tiếng: các closure trong một vòng lặp đều bắt *cùng* biến vòng lặp. (Go 1.22 đã sửa phạm vi biến vòng lặp, nhưng hiểu vấn đề này quan trọng cho code cũ và các biến được bắt khác.)

## Các cách dùng closure phổ biến

```go
// 1. như callback / handler
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. các hàm defer bắt trạng thái cục bộ
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factory (hành vi được cấu hình)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## Tại sao điều này quan trọng

Closure là một tính năng Go mạnh mẽ, được dùng thường xuyên, được cho phép bởi các hàm first-class — chúng cho phép bạn tạo các hàm mang theo trạng thái riêng tư, bền vững (bộ đếm, generator, hành vi được cấu hình qua các function factory) và thiết yếu cho callback, HTTP handler, dọn dẹp defer tham chiếu biến cục bộ, và các pattern hàm.

Hiểu rằng closure bắt biến **theo tham chiếu** (thấy giá trị hiện tại, chia sẻ trạng thái) — không phải theo giá trị — là then chốt cả để dùng chúng hiệu quả (trạng thái có thể thay đổi được đóng gói) lẫn để tránh **lỗi bắt biến vòng lặp kinh điển** (tất cả closure chung một biến, một nguồn nhầm lẫn nổi tiếng, đã được sửa trong Go 1.22 nhưng vẫn liên quan cho code cũ và các bắt biến ngoài vòng lặp).

Closure xuất hiện khắp Go idiomatic và các API thư viện chuẩn, khiến chúng là kiến thức thực tế quan trọng và một chủ đề phỏng vấn lặp lại.