Hvordan fungerer closures i Go?

Question

Accepted Answer

En **closure** er en funksjon som refererer til variabler fra sitt omsluttende omfang, "lukker over" dem — funksjonen beholder tilgang til disse variablene selv etter at den omsluttende funksjonen returnerer. Go-funksjoner er førsteklasses verdier, noe som gjør closures til et vanlig og kraftig verktøy.

## En grunnleggende closure

```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
```

Den returnerte funksjonen beholder en referanse til `count` selv etter at `makeCounter` returnerer — så tilstanden persistererer på tvers av kall. Hvert kall til `makeCounter` oppretter en frisk, uavhengig `count`. Dette er innkapslet privat tilstand.

## Closures fanger opp variabler ETTER REFERANSE (viktig poeng)

```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
```

## Den klassiske løkkevariabel-gotchaen

```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.
```

Dette er en kjent feil: closures i en løkke fanget alle opp den *samme* løkkevariabelen. (Go 1.22 fikset løkkevariabelen-omfang, men forståelsen av problemet betyr noe for eldre kode og andre fangede variabler.)

## Vanlige bruksområder for 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
```

## Hvorfor det betyr noe

Closures er et kraftig, ofte brukt Go-feature som blir muliggjort av førsteklasses funksjoner — de lar deg opprette funksjoner som bærer privat, persistent tilstand (tellere, generatorer, konfigurert oppførsel via fabrikk-funksjoner) og er essensielle for callbacks, HTTP-behandlere, utsatt opprydding som refererer til lokale variabler, og funksjonsielle mønstre.

Forståelsen av at closures fanger opp variabler **etter referanse** (ser gjeldende verdier, deler tilstand) — ikke etter verdi — er avgjørende både for å bruke dem effektivt (innkapslet muterbar tilstand) og for å unngå **den klassiske løkkevariabel-fangst-feilen** (alle closures deler en variabel, en beryktet kilde til forvirring, nå fikset i Go 1.22 men fortsatt relevant for eldre kode og ikke-løkke-fangst).

Closures vises gjennomgående i idiomatisk Go og standard-bibliotek-APIer, noe som gjør dem til viktig praktisk kunnskap og et tilbakevendende intervjuemne.