Go Academy · Lekcja

Generyczne struktury danych

Tworzenie generycznego Stack i Set

Generyczne struktury danych to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 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.

Po co generyczne struktury danych?

Przed wprowadzeniem generyczności programiści Go używali slice’ów typu interface{} (tracąc bezpieczeństwo typów) albo generowali kod osobno dla każdego typu. Generyczność umożliwia tworzenie bezpiecznych typowo kontenerów wielokrotnego użytku.

Generyczny stos

Bezpieczny typowo stos wykorzystujący typ generyczny:

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 z T; return z, false }
    n := len(s.items)-1; v := s.items[n]; s.items = s.items[:n]; return v, true
}
func (s *Stack[T]) Len() int { return len(s.items) }

Generyczna kolejka

Kolejka FIFO oparta na slice:

type Queue[T any] struct{ items []T }
func (q *Queue[T]) Enqueue(v T)     { q.items = append(q.items, v) }
func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items)==0 { var z T; return z, false }
    v := q.items[0]; q.items = q.items[1:]; return v, true
}

Generyczny zbiór

Zbiór oparty na mapie — typ klucza musi być porównywalny:

type Set[T comparable] struct{ m map[T]struct{} }
func NewSet[T comparable]() *Set[T] { return &Set[T]{m: make(map[T]struct{})} }
func (s *Set[T]) Add(v T)          { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool     { _, ok := s.m[v]; return ok }
func (s *Set[T]) Delete(v T)       { delete(s.m, v) }

Generyczny pomocnik Map

Bezpieczna typowo funkcyjna funkcja Map działająca na slice’ach:

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

Generyczny Filter

Zwraca nowy slice zawierający tylko elementy spełniające predykat:

func Filter[T any](s []T, predicate func(T) bool) []T {
    var out []T
    for _, v := range s {
        if predicate(v) { out = append(out, v) }
    }
    return out
}

Generyczny Reduce

Redukuje slice do jednej wartości:

func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
    acc := init
    for _, v := range s { acc = f(acc, v) }
    return acc
}

OrderedMap

Uporządkowana mapa zachowująca kolejność wstawiania — przydatna podczas serializacji JSON ze stabilną kolejnością kluczy:

type OrderedMap[K comparable, V any] struct {
    keys []K
    vals map[K]V
}

Generyczna lista wiązana

Dwukierunkowa lista wiązana z elementami bezpiecznymi typowo:

type Node[T any] struct{ Val T; Next, Prev *Node[T] }
type List[T any] struct{ head, tail *Node[T]; len int }

Ograniczenia

Typy generyczne nie mogą używać type switch na T. Metody typów generycznych nie mogą wprowadzać nowych parametrów typu. Nie można specjalizować typu generycznego dla konkretnego T (brak specjalizacji szablonów).

Wydajność

Instancjowanie generyczne w Go odbywa się za pomocą „kształtów GC” — typy o takim samym układzie pamięci współdzielą jedną implementację. Ogranicza to rozrost kodu, zachowując wydajność zbliżoną do implementacji dla typów konkretnych.

Kiedy nie używać generyczności

Należy unikać generyczności w prostych przypadkach, w których wystarcza interfejs, oraz wtedy, gdy występuje tylko jeden lub dwa typy konkretne — dodatkowa złożoność przewyższa korzyści.

Szybkie sprawdzenie

Dlaczego generyczny Set wymaga ograniczenia comparable dla swojego parametru typu?

Podsumowanie: generyczne struktury danych

Najważniejsze informacje:

Stack, Queue i Set — bezpieczeństwo typów dzięki generyczności
Funkcje pomocnicze Map, Filter i Reduce działające na []T
Set[T comparable] dla zbiorów opartych na mapach
Brak parametrów typu na poziomie metod; brak specjalizacji szablonów

Często zadawane pytania

Czy lekcja „Generyczne struktury danych” jest bezpłatna?

Tak — pełny tekst „Generyczne struktury danych” 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 „Generyczne struktury danych”?

Tworzenie generycznego Stack i Set Ć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 3 z 4.

Ile czasu zajmuje lekcja „Generyczne struktury danych”?

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