0Pricing
Go Academy · Lektion

defer, anonyme Funktionen und Closures

Aufgeschobene Aufrufe und Funktionswerte

defer, anonyme Funktionen und Closures ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

defer: Verzögerte Ausführung

defer plant einen Funktionsaufruf für die Ausführung ein, sobald die umgebende Funktion zurückkehrt – unabhängig davon, wie sie zurückkehrt (normal, mit einem Fehler, durch panic):

func readFile(path string) {
    f, err := os.Open(path)
    if err != nil { return }
    defer f.Close() // runs when readFile returns
    // read from f...
}

Auswertungsreihenfolge bei defer

Zurückgestellte Aufrufe werden auf einen Stack gelegt und in LIFO-Reihenfolge ausgeführt (last-in, first-out):

func main() {
    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // Output: first, second, third
}

defer zur Bereinigung

defer ist die idiomatische Möglichkeit, sicherzustellen, dass Ressourcen freigegeben werden:

  • Entsperren Sie einen Mutex nach dem Sperren
  • Schließen Sie eine Datei nach dem Öffnen
  • Führen Sie ein Datenbank-Transaktion aus oder rollen Sie sie zurück
  • Rufen Sie WaitGroup.Done() nach WaitGroup.Add() auf

defer mit Argumenten

Die Argumente eines zurückgestellten Aufrufs werden sofort ausgewertet, wenn defer aufgerufen wird, und nicht erst bei seiner Ausführung:

x := 10
defer fmt.Println(x) // prints 10, not 20
x = 20
fmt.Println(x)       // prints 20

Anonyme Funktionen

Anonyme Funktionen (Funktionsliterale) werden inline und ohne Namen definiert:

double := func(n int) int {
    return n * 2
}
fmt.Println(double(5)) // 10

// Immediately invoked:
result := func(a, b int) int { return a + b }(3, 4)

Closures

Eine Closure ist eine Funktion, die Variablen aus ihrem umgebenden Gültigkeitsbereich erfasst:

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

ctr := makeCounter()
fmt.Println(ctr(), ctr(), ctr()) // 1 2 3

Fallstrick bei der Closure-Erfassung in Schleifen

Closures erfassen Variablen per Referenz – ein häufiger Fehler bei Goroutine-Schleifen:

for i := 0; i < 3; i++ {
    i := i // create a new variable per iteration
    go func() { fmt.Println(i) }()
}

defer mit benannten Rückgaben

Zurückgestellte Funktionen können benannte Rückgabewerte ändern – nützlich, um Fehler mit zusätzlichen Informationen zu versehen:

func doWork() (err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("doWork: %w", err)
        }
    }()
    return riskyOp()
}

Funktionale Muster mit Closures

Closures ermöglichen funktionale Muster wie Memoization:

func memoize(f func(int) int) func(int) int {
    cache := map[int]int{}
    return func(n int) int {
        if v, ok := cache[n]; ok {
            return v
        }
        v := f(n)
        cache[n] = v
        return v
    }
}

Closures als Middleware

Closures bilden die Grundlage für Middleware in Go-HTTP-Servern – sie umschließen einen Handler und fügen Verhalten um ihn herum hinzu:

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL)
        next(w, r)
    }
}

Kurze Überprüfung

Wann werden die Argumente eines zurückgestellten Funktionsaufrufs ausgewertet?

Rückblick: defer, Closures und anonyme Funktionen

Diese Funktionen machen Go-Code ausdrucksstark und sicher:

  • defer garantiert die Bereinigung beim Verlassen einer Funktion – in LIFO-Reihenfolge
  • Argumente von defer werden sofort ausgewertet
  • Anonyme Funktionen können Variablen zugewiesen oder inline aufgerufen werden
  • Closures erfassen umgebende Variablen per Referenz
  • Achten Sie bei Goroutinen auf Fehler durch die Erfassung von Schleifenvariablen

Nächster Kurs: Arrays, Slices und Maps.

Häufig gestellte Fragen

Ist die Lektion „defer, anonyme Funktionen und Closures“ kostenlos?

Ja — der vollständige Text von „defer, anonyme Funktionen und Closures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „defer, anonyme Funktionen und Closures“?

Aufgeschobene Aufrufe und Funktionswerte Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „defer, anonyme Funktionen und Closures“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Grundlagen und Signaturen von Funktionen
  2. Mehrere Rückgabewerte
  3. Variadische Funktionen
  4. defer, anonyme Funktionen und Closures
← Zurück zu Go Academy