Go Academy · Lekcja

Składnia parametrów typów

Funkcje i typy generyczne z użyciem [T any]

Składnia parametrów typów to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 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.

Podstawy generyków

Przed Go 1.18 kod działający dla wielu typów wymagał użycia interface{}/any (co oznaczało utratę bezpieczeństwa typów) albo generowania kodu. Generyki dodają parametry typów na potrzeby polimorfizmu sprawdzanego podczas kompilacji.

Składnia funkcji generycznej

Proszę deklarować parametry typów w nawiasach kwadratowych umieszczonych za nazwą funkcji:

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := Map([]int{1,2,3}, func(n int) string {
    return strconv.Itoa(n)
})

Wnioskowanie typu

W większości przypadków kompilator wnioskuje argumenty typów na podstawie argumentów funkcji. Jeśli wnioskowanie się nie powiedzie, można określić je jawnie.

// Inferred:
nums := Map([]int{1,2,3}, strconv.Itoa)
// Explicit:
nums := Map[int, string]([]int{1,2,3}, strconv.Itoa)

Typy generyczne

Struktury i inne typy również mogą mieć parametry typów:

type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 { var zero T; return zero, false }
    n := len(s.items)-1
    v := s.items[n]
    s.items = s.items[:n]
    return v, true
}

Wiele parametrów typów

Funkcje i typy mogą mieć wiele parametrów typów:

type Pair[K, V any] struct { Key K; Value V }

func Zip[K, V any](keys []K, vals []V) []Pair[K, V] {
    result := make([]Pair[K, V], min(len(keys), len(vals)))
    for i := range result {
        result[i] = Pair[K, V]{keys[i], vals[i]}
    }
    return result
}

Wartość zerowa parametru typu

Proszę zadeklarować zmienną zawierającą wartość zerową za pomocą var zero T. Jest to konieczne podczas zwracania wyniku „brak wartości” z funkcji generycznej.

func First[T any](s []T) (T, bool) {
    if len(s) == 0 { var zero T; return zero, false }
    return s[0], true
}

Metody typów generycznych

Metody typu generycznego używają parametrów tego typu, a nie własnych. Metoda nie może wprowadzać dodatkowych parametrów typów.

type Pair[K, V any] struct{ K K; V V }
func (p Pair[K, V]) Swap() Pair[V, K] { return Pair[V, K]{p.V, p.K} }

Instancjowanie

Użycie typu generycznego z konkretnym argumentem typu nazywa się instancjowaniem. Odbywa się ono podczas kompilacji, a nie w czasie działania — nie występuje narzut związany z opakowywaniem.

s := Stack[int]{}
s.Push(42)

Aliasy typów i typy generyczne

Można tworzyć aliasy typów dla instancjonowanych typów generycznych:

type IntStack = Stack[int]

Ograniczenia

Parametrów typów nie można używać z przełącznikami typów ani asercjami typów. Metody typów generycznych nie mogą mieć dodatkowych parametrów typów. Generyków nie można używać dla typów z przeciążonymi operatorami bez ograniczeń.

Kiedy używać generyków

Proszę używać generyków w przypadku algorytmów rzeczywiście niezależnych od typu (typów kontenerowych oraz pomocniczych funkcji funkcyjnych, takich jak Map/Filter/Reduce), gdy alternatywą byłoby powielanie kodu lub niebezpieczne rzutowania.

Szybkie sprawdzenie

Gdzie deklaruje się parametry typów w funkcji generycznej?

Podsumowanie: składnia parametrów typów

Najważniejsze informacje:

Parametry typów w nawiasach kwadratowych: func Foo[T any](...)
Działają w funkcjach i typach (strukturach itp.)
W większości przypadków kompilator wnioskuje argumenty typów na podstawie argumentów
Wartość zerowa: var zero T; brak parametrów typów na poziomie metody

Często zadawane pytania

Czy lekcja „Składnia parametrów typów” jest bezpłatna?

Tak — pełny tekst „Składnia parametrów typów” 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 „Składnia parametrów typów”?

Funkcje i typy generyczne z użyciem [T any] Ć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 1 z 4.

Ile czasu zajmuje lekcja „Składnia parametrów typów”?

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