Go Academy · Lektion

defer, anonyme funktioner og closures

Udskudte kald og funktionsværdier

Lektion 4 af 412 trin

defer, anonyme funktioner og closures er en gratis Go Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Go Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Go Academy-kurset indeholder 4 lektioner i alt.

defer: udskudt udførelse

defer planlægger et funktionskald, som skal udføres, når den omgivende funktion returnerer — uanset hvordan den returnerer (normalt, med en fejl eller ved panic):

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

defer-rækkefølge

Udskudte kald lægges på en stak og udføres i LIFO-rækkefølge (sidst ind, først ud):

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

defer til oprydning

defer er den idiomatiske måde at sikre, at ressourcer frigives:

Lås en mutex op efter at have låst den
Luk en fil efter at have åbnet den
Commit eller rul en databasetransaktion tilbage
Kald WaitGroup.Done() efter WaitGroup.Add()

defer med argumenter

Argumenterne til et udskudt kald evalueres med det samme, når defer kaldes, ikke når kaldet udføres:

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

Anonyme funktioner

Anonyme funktioner (funktionsliteraler) defineres direkte i koden uden et navn:

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

En closure er en funktion, der indfanger variabler fra sit omgivende område:

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

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

Faldgrube ved closures i løkker

Closures indfanger variabler via reference — en almindelig fejl i goroutine-løkker:

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

defer med navngivne returværdier

Udskudte funktioner kan ændre navngivne returværdier — nyttigt til at tilføje oplysninger til fejl:

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

Funktionelle mønstre med closures

Closures muliggør funktionelle mønstre som memoisering:

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 som middleware

Closures er byggestenen til middleware i Go HTTP-servere — de omslutter en handler og tilføjer adfærd omkring den:

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)
    }
}

Hurtigt tjek

Hvornår evalueres argumenterne til et udskudt funktionskald?

Besvar den i den interaktive lektion

Opsamling: defer, closures og anonyme funktioner

Disse funktioner gør Go-kode udtryksfuld og sikker:

defer garanterer oprydning, når funktionen afsluttes — i LIFO-rækkefølge
Argumenter til defer evalueres med det samme
Anonyme funktioner kan tildeles til variabler eller kaldes direkte
Closures indfanger omgivende variabler via reference
Vær opmærksom på fejl, hvor løkkevariabler indfanges i goroutines

Næste kursus: arrays, slices og maps.

Gratis at komme i gang

Lær Go med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “defer, anonyme funktioner og closures” gratis?

Ja — alle 3 lektioner i læringssporet Go Academy, inklusive “defer, anonyme funktioner og closures”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “defer, anonyme funktioner og closures”?

Udskudte kald og funktionsværdier Du øver dig i Go Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Go Academy?

Der kræves ingen tidligere erfaring. Go Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “defer, anonyme funktioner og closures”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Go Academy-lektion?

Ja. Alle Go Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Go Academy