Conas a oibríonn closures i Go?

Question

Accepted Answer

Is **closure** feidhm a bhíonn tagairt aici do athróga ó a scóip thimpeallach, "ag dúnadh orthu" — coimeádann an fheidhm rochtain ar na hathróga sin fiú tar éis go bhfillfeann an fheidhm dhúnta. Is feidhmeanna den chéad-ord iad feidhmeanna Go, rud a dhéanann closures ina dtúl coitianta agus cumhachtach.

## Closure bunúsach

```go
func makeCounter() func() int {
    count := 0                  // a local variable
    return func() int {          // this inner function CLOSES OVER count
        count++                  // it can read AND modify count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count PERSISTS between calls (state is retained)

other := makeCounter()    // a NEW, independent closure with its own count
fmt.Println(other())     // 1 — separate state
```

Coimeádann an fheidhm ar ais tagairt do `count` fiú tar éis go bhfillfeann `makeCounter` — mar sin maireann an stáit thar na glaonna. Cruthaíonn gach glaoch ar `makeCounter` `count` nua, neamhspleách. Is é seo stáit phríobháideach dhúnta.

## Gabhann closures athróga trí THAGAIRT (pointe ríthábhachtach)

```go
// closures capture the variable itself, not a snapshot of its value
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — sees the CURRENT value of x, not 10
```

## An gréim clasaiceach athróg an lúip

```go
// ⚠️ in Go versions BEFORE 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // all close over the SAME i
}
for _, f := range funcs { f() }   // prints 3, 3, 3 (not 0, 1, 2)! — all share i

// the classic fix (pre-1.22): make a per-iteration copy
for i := 0; i < 3; i++ {
    i := i                          // shadow with a new variable each iteration
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Note: Go 1.22+ changed loop semantics so each iteration gets a NEW variable — this bug is fixed.
```

Is bug iomráiteach é seo: ghabh gach closure i lúip an *same* athróg an lúip. (Bhain Go 1.22 scóip-an-athróg-lúip amach, ach tá an tábhacht ag baint le tuiscint ar an bhfadhb do sheanchodanna agus athróga gabtha eile.)

## Úsáidí coitianta closures

```go
// 1. as callbacks / handlers
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. deferred functions capturing local state
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factories (configured behavior)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## Cén fáth a bhfuil sé tábhachtach

Is gné chumhachtach, go minic-úsáidte atá closures in Go, ar a bhféadann feidhmeanna den chéad-ord a dhéanamh — tugann siad deis duit feidhmeanna a chruthú a iompaíonn stáit phríobháideach, bhuan (cunntairí, gineadóirí, iompraíochtaí cumraithe trí fheidhmeanna fábrica) agus tá siad riachtanach do ghairmeacha siar, feidhmitheoir HTTP, glanadh sealadh a bhíonn tagairt aici do athróga logánta, agus patrúin fheidhmiúla.

Tá sé ríthábhachtach a thuiscint go ngabhann closures athróga **trí thagairt** (ag feiceáil luachanna reatha, ag roinnt stáit) — ní trí luach — agus tá sé riachtanach chun iad a úsáid go héifeachtach (stáit inmhalairt dhúnta) agus chun an **gréim clasaiceach gabhála athróg an lúip** a sheachaint (gach closure ag roinnt athróg amháin, foinse nótáilte mearbhaill, ó bhí sé ceartaithe in Go 1.22 ach fós ábhairí do sheanchódanna agus gabhála neamh-lúip).

Bíonn closures le fáil i ngach áit in Go idiomatach agus in API an leabharlann chaighdeánach, agus déanann sin iad tábhachtach do gheal-eolas praiticiúil agus ábhar athdhéanta an bhabhta agallaimh.