Go Academy · Lekcja

defer, funkcje anonimowe i domknięcia

Odroczone wywołania i wartości funkcyjne

defer, funkcje anonimowe i domknięcia to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

defer: odroczone wykonanie

defer planuje wywołanie funkcji, które zostanie wykonane, gdy otaczająca funkcja zakończy działanie — niezależnie od sposobu zakończenia (normalnego, w wyniku błędu lub przez panic):

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

Kolejność wykonywania defer

Odroczone wywołania są umieszczane na stosie i wykonywane w kolejności LIFO (ostatnie weszło, pierwsze wyszło):

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

defer do sprzątania

defer to idiomatyczny sposób zapewnienia zwolnienia zasobów:

Odblokowanie muteksu po jego zablokowaniu
Zamknięcie pliku po jego otwarciu
Zatwierdzenie transakcji bazy danych lub wycofanie jej
Wywołanie WaitGroup.Done() po WaitGroup.Add()

defer z argumentami

Argumenty odroczonego wywołania są obliczane natychmiast w chwili wywołania defer, a nie w momencie wykonania:

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

Funkcje anonimowe

Funkcje anonimowe (literały funkcji) są definiowane bezpośrednio, bez nazwy:

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)

Domknięcia

Domknięcie to funkcja, która przechwytuje zmienne z otaczającego zakresu:

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

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

Pułapka przechwytywania w domknięciach w pętlach

Domknięcia przechwytują zmienne przez referencję — jest to częsta przyczyna błędów w pętlach z goroutines:

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

defer z nazwanymi wartościami zwracanymi

Funkcje odroczone mogą modyfikować nazwane wartości zwracane — jest to przydatne do dodawania informacji do błędów:

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

Wzorce funkcyjne z domknięciami

Domknięcia umożliwiają stosowanie wzorców funkcyjnych, takich jak zapamiętywanie wyników:

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

Domknięcia jako middleware

Domknięcia są podstawowym elementem middleware w serwerach HTTP języka Go — opakowują procedurę obsługi i dodają zachowanie przed jej wykonaniem lub po nim:

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

Szybkie sprawdzenie

Kiedy są obliczane argumenty odroczonego wywołania funkcji?

Podsumowanie: defer, domknięcia i funkcje anonimowe

Te funkcje sprawiają, że kod Go jest wyrazisty i bezpieczny:

defer gwarantuje sprzątanie przy wyjściu z funkcji — w kolejności LIFO
Argumenty defer są obliczane natychmiast
Funkcje anonimowe można przypisywać do zmiennych lub wywoływać bezpośrednio
Domknięcia przechwytują otaczające zmienne przez referencję
Należy uważać na błędy przechwytywania zmiennych pętli w goroutines

Następny kurs: tablice, wycinki i mapy.

Często zadawane pytania

Czy lekcja „defer, funkcje anonimowe i domknięcia” jest bezpłatna?

Tak — pełny tekst „defer, funkcje anonimowe i domknięcia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „defer, funkcje anonimowe i domknięcia”?

Odroczone wywołania i wartości funkcyjne Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „defer, funkcje anonimowe i domknięcia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy