Generics in Go: warum sie nützlich sind und wie man sie für Anfänger verwendet

Einleitung: Was sind Generics und warum wurden sie in Go eingeführt?

Lange Zeit blieb die Sprache Go (Golang) eine der wenigen modernen Sprachen ohne Unterstützung für generische Programmierung (Generics). Entwickler mussten entweder Code für verschiedene Datentypen duplizieren oder Schnittstellen und leere interface{} verwenden, was zu einem Verlust der Typsicherheit und der Notwendigkeit führte, Typumwandlungen zur Laufzeit durchzuführen.

Mit der Veröffentlichung von Go 1.18 (Februar 2022) wurden die lang erwarteten Generics in die Sprache eingeführt. Generics sind ein Mechanismus, der es ermöglicht, Funktionen, Typen und Datenstrukturen zu schreiben, die mit beliebigen Typen arbeiten, während gleichzeitig eine strenge Typisierung zur Kompilierzeit erhalten bleibt.

In diesem Artikel werden wir behandeln:

\n
• Warum Generics in Go nützlich sind;
\n
• Wie man generische Funktionen und Typen deklariert;
\n
• Was Constraints sind und wie man sie verwendet;
\n
• Praktische Anwendungsbeispiele.
\n

Warum sind Generics in Go nützlich?

Vor der Einführung von Generics sah ein typisches Problem so aus: Man musste eine Funktion schreiben, die mit Slices verschiedener Typen arbeitet (z. B. int, string, float64).

Ohne Generics musste man entweder drei separate Funktionen schreiben:

func SumInts(nums []int) int {\n    total := 0\n    for _, v := range nums {\n        total += v\n    }\n    return total\n}\n\nfunc SumFloats(nums []float64) float64 {\n    total := 0.0\n    for _, v := range nums {\n        total += v\n    }\n    return total\n}\n

Oder interface{} mit Typumwandlung verwenden – unsicher und umständlich.

Mit Generics reicht eine einzige Funktion:

func Sum[T int | float64](nums []T) T {\n    var total T\n    for _, v := range nums {\n        total += v\n    }\n    return total\n}\n

Die Vorteile liegen auf der Hand:

\n
• Typsicherheit – Typfehler werden zur Kompilierzeit abgefangen;
\n
• Reduzierung von Code-Duplizierung – eine Funktion für viele Typen;
\n
• Lesbarkeit – der Code wird prägnanter und verständlicher.
\n

Grundlagen der Generics-Syntax in Go

Deklaration einer generischen Funktion

Die grundlegende Syntax verwendet eckige Klammern [] zur Angabe der Typparameter:

func Funktionsname[Typname constraint](Parameter) Ergebnis {\n    // Funktionskörper\n}\n

Beispiel einer einfachen Funktion, die den übergebenen Wert zurückgibt:

func Identity[T any](value T) T {\n    return value\n}\n\nfunc main() {\n    fmt.Println(Identity[int](42))       // 42\n    fmt.Println(Identity[string]("Go"))  // Go\n}\n

Go kann den Typ automatisch ableiten, daher ist die explizite Angabe von [int] nicht erforderlich:

fmt.Println(Identity(42))       // Go erkennt selbst, dass T = int\nfmt.Println(Identity("Go"))    // T = string\n

Generische Typen (Strukturen)

Generics funktionieren nicht nur mit Funktionen, sondern auch mit benutzerdefinierten Typen:

type Stack[T any] struct {\n    elements []T\n}\n\nfunc (s *Stack[T]) Push(value T) {\n    s.elements = append(s.elements, value)\n}\n\nfunc (s *Stack[T]) Pop() (T, bool) {\n    if len(s.elements) == 0 {\n        var zero T\n        return zero, false\n    }\n    value := s.elements[len(s.elements)-1]\n    s.elements = s.elements[:len(s.elements)-1]\n    return value, true\n}\n\nfunc main() {\n    intStack := Stack[int]{}\n    intStack.Push(10)\n    intStack.Push(20)\n    val, ok := intStack.Pop()\n    fmt.Println(val, ok) // 20 true\n}\n

Constraints: Einschränkungen für Typen

In den obigen Beispielen haben wir any verwendet – dies ist ein eingebauter Constraint, der "beliebiger Typ" bedeutet. Oft ist es jedoch erforderlich, Einschränkungen aufzuerlegen: z. B. dass der Typ Vergleiche oder arithmetische Operationen unterstützt.

Eingebaute