Miten sulkeumafunktiot (closures) toimivat Go-kielessä?

Question

Accepted Answer

**Sulkeumafunktio** (closure) on funktio, joka viittaa muuttujiin ympäröivästä laajuudestaan (scope), "sulkien ne sisäänsä" — funktio säilyttää pääsyn näihin muuttujiin jopa sen jälkeen, kun ympäröivä funktio palaa. Go-funktiot ovat ensimmäisen luokan arvoja, mikä tekee sulkeumafunktioista yleisiä ja tehokkaita työkaluja.

## Perusesimerkki sulkeumafunktiosta

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

Palaautettu funktio säilyttää viitteen `count`-muuttujaan jopa sen jälkeen, kun `makeCounter` palaa — joten tila jää muistiin kutsujen välillä. Jokainen `makeCounter`-kutsu luo uuden, itsenäisen `count`-muuttujan. Tämä on kapseloitu yksityinen tila.

## Sulkeumafunktiot kaappavat muuttujat VIITTEEN KAUTTA (keskeinen asia)

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

## Klassinen silmukan muuttuja -ongelma

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

Tämä on kuuluisa virhe: sulkeumafunktiot silmukassa kaappasivat *saman* silmukan muuttujan. (Go 1.22 korjasi silmukan muuttujan laajuuden, mutta ongelman ymmärtäminen on tärkeää vanhemmalle koodille ja muille kaappatuille muuttujille.)

## Sulkeumafunktioiden yleiset käyttötavat

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

## Miksi se on tärkeää

Sulkeumafunktiot ovat tehokas, usein käytetty Go-ominaisuus, jonka mahdollistavat ensimmäisen luokan funktiot — niiden avulla voit luoda funktioita, jotka kantavat mukanaan yksityistä, pysyvää tilaa (laskureita, generaattoreita, käyttäytymisiä konfiguroitujen tehtaiden kautta), ja ne ovat välttämättömiä takaisinkutsuille, HTTP-käsittelijöille, lykättylle puhdistamiselle, joka viittaa paikallisiin muuttujiin, sekä funktionaalisille malleille.

Se, että sulkeumafunktiot kaappavat muuttujat **viitteen kautta** (näkevät nykyiset arvot, jakavat tilan) — ei arvojen kautta — on ratkaisevan tärkeää sekä niiden tehokkaalle käytölle (kapseloitu muuttuva tila) että **klassisen silmukan muuttuja -ongelman** välttämiselle (kaikki sulkeumafunktiot jakavat yhden muuttujan, kuuluisa sekaannuksen lähde, joka on korjattu Go 1.22:ssa mutta silti relevantti vanhemmalle koodille ja ei-silmukan kaappauksille).

Sulkeumafunktiot esiintyvät kaikkialla idiomaattisessa Go-koodissa ja vakiokirjaston ohjelmointirajapinnoissa, mikä tekee niistä tärkeää käytännön tietoa ja toistuvaa haastattelukysymystä.