Go Academy · Lektion

Generische Datenstrukturen

Einen generischen Stack und ein generisches Set erstellen

Generische Datenstrukturen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Warum generische Datenstrukturen?

Vor Generics verwendeten Go-Entwickler Slices vom Typ interface{} (wodurch Typsicherheit verloren ging) oder erzeugten Code für jeden Typ. Generics ermöglichen typsichere, wiederverwendbare Container.

Generischer Stack

Ein typsicherer Stack mit einem generischen Typ:

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

Generische Queue

Eine FIFO-Queue, die auf einer Slice basiert:

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
}

Generisches Set

Ein Set, das auf einer Map basiert – der Schlüsseltyp muss vergleichbar sein:

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

Generischer Map-Helfer

Eine typsichere funktionale Map-Operation für Slices:

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
}

Generischer Filter

Gibt eine neue Slice zurück, die nur Elemente enthält, die ein Prädikat erfüllen:

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
}

Generische Reduktion

Fasst eine Slice zu einem einzelnen Wert zusammen:

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

Eine geordnete Map, die die Einfügereihenfolge beibehält – nützlich für die JSON-Serialisierung mit einer stabilen Schlüsselreihenfolge:

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

Generische verkettete Liste

Eine doppelt verkettete Liste mit typsicheren Elementen:

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

Einschränkungen

Generische Typen können keine Type-Switches auf T verwenden. Methoden generischer Typen können keine neuen Typparameter einführen. Sie können einen generischen Typ nicht für ein bestimmtes T spezialisieren (keine Template-Spezialisierung).

Leistung

Die Instanziierung von Generics erfolgt in Go über "GC shapes" – Typen mit demselben Speicherlayout teilen sich eine Implementierung. Dadurch wird eine übermäßige Codegröße vermieden, während die Leistung nahe an der konkreter Implementierungen bleibt.

Wann Generics nicht verwendet werden sollten

Vermeiden Sie Generics in einfachen Fällen, in denen ein Interface ausreicht, oder wenn Sie nur einen oder zwei konkrete Typen haben – die zusätzliche Komplexität wiegt den Nutzen auf.

Schnelltest

Warum benötigt ein generisches Set das Constraint comparable für seinen Typparameter?

Zusammenfassung: Generische Datenstrukturen

Wichtige Punkte:

Stack, Queue, Set – typsicher dank Generics
Funktionale Helfer: Map, Filter, Reduce für []T
Set[T comparable] für Maps-basierte Sets
Keine methodenbezogenen Typparameter; keine Template-Spezialisierung

Häufig gestellte Fragen

Ist die Lektion „Generische Datenstrukturen“ kostenlos?

Ja — der vollständige Text von „Generische Datenstrukturen“ 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 „Generische Datenstrukturen“?

Einen generischen Stack und ein generisches Set erstellen 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 3 von 4.

Wie lange dauert die Lektion „Generische Datenstrukturen“?

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

← Zurück zu Go Academy