Πώς λειτουργούν τα closures στη Go;

Question

Accepted Answer

Ένα **closure** είναι μια συνάρτηση που αναφέρεται σε μεταβλητές από το περιβάλλον εμβέλειάς της, «κλείνοντας» πάνω τους — η συνάρτηση διατηρεί πρόσβαση σε αυτές τις μεταβλητές ακόμα και μετά την επιστροφή της συνάρτησης που τα περιέχει. Οι συναρτήσεις στη Go είναι first-class values, καθιστώντας τα closures ένα κοινό και ισχυρό εργαλείο.

## Ένα βασικό 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
```

Η επιστρεφόμενη συνάρτηση διατηρεί μια αναφορά στο `count` ακόμα και μετά την επιστροφή του `makeCounter` — επομένως η κατάσταση παραμένει σταθερή σε όλες τις κλήσεις. Κάθε κλήση στο `makeCounter` δημιουργεί ένα νέο, ανεξάρτητο `count`. Αυτό είναι κενό ιδιωτικής κατάστασης.

## Τα closures καταγράφουν μεταβλητές ΑΠΟ ΑΝΑΦΟΡΑ (κρίσιμο σημείο)

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

## Το κλασικό πρόβλημα μεταβλητής βρόχου

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

Αυτό είναι ένα περίφημο σφάλμα: τα closures σε ένα βρόχο όλα κατέγραψαν την *ίδια* μεταβλητή βρόχου. (Η Go 1.22 διόρθωσε την εμβέλεια μεταβλητής βρόχου, αλλά η κατανόηση του προβλήματος είναι σημαντική για παλαιότερο κώδικα και άλλες καταγεγραμμένες μεταβλητές.)

## Κοινές χρήσεις 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
```

## Γιατί είναι σημαντικό

Τα closures είναι ένα ισχυρό, συχνά χρησιμοποιούμενο χαρακτηριστικό της Go που ενεργοποιείται από first-class functions — σας επιτρέπουν να δημιουργήσετε συναρτήσεις που φέρουν ιδιωτική, επίμονη κατάσταση (μετρητές, γεννήτριες, διαμορφωμένες συμπεριφορές μέσω factory functions) και είναι απαραίτητα για callbacks, HTTP handlers, deferred cleanup που αναφέρεται σε τοπικές μεταβλητές, και λειτουργικά πρότυπα.

Η κατανόηση ότι τα closures καταγράφουν μεταβλητές **ανά αναφορά** (βλέποντας τρέχουσες τιμές, μοιράζοντας κατάσταση) — όχι ανά τιμή — είναι κρίσιμη τόσο για τη χρήση τους αποτελεσματικά (κενή μεταβλητή κατάσταση) όσο και για την αποφυγή του **κλασικού σφάλματος καταγραφής μεταβλητής βρόχου** (όλα τα closures μοιράζονται μια μεταβλητή, ένα περίφημο πηγή σύγχυσης, αποδεικτικά διορθώθηκε στη Go 1.22 αλλά εξακολουθεί να είναι σχετικό για παλαιότερο κώδικα και μη-loop captures).

Τα closures εμφανίζονται σε όλη την idiomatική Go και τα APIs της standard library, καθιστώντας τα σημαντική πρακτική γνώση και ένα επαναλαμβανόμενο θέμα συνέντευξης.