Generics in Go: warum sie nötig sind und wie man sie in der Praxis einsetzt

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einleitung: Warum sind Generics in Go ein Durchbruch?

Lange Zeit blieb die Sprache Go (Golang) eine der wenigen modernen Sprachen ohne Unterstützung für generische Programmierung (Generics). Entwickler waren gezwungen, interface{} und Typumwandlungen zu verwenden, was zu einem Verlust der Typsicherheit zur Kompilierzeit führte und den Code aufblähte. Mit der Veröffentlichung von Go Version 1.18 (Februar 2022) hat sich die Situation grundlegend geändert.

Generics (Generika) sind ein Mechanismus, der es ermöglicht, Funktionen und Datenstrukturen zu schreiben, die mit beliebigen Typen arbeiten können, während die strenge Typisierung erhalten bleibt. In diesem Artikel werden wir untersuchen, warum sie benötigt werden, und anhand praktischer Beispiele zeigen, wie man sie in der täglichen Go-Entwicklung einsetzt.

Warum werden Generics in Go benötigt?

Vor dem Aufkommen von Generics verwendeten Entwickler interface{} (leeres Interface), um universelle Funktionen zu erstellen. Betrachten wir ein klassisches Beispiel – eine Funktion, die das kleinste Element in einem Slice findet:

// Ohne Generics (Go < 1.18)func MinInt(a, b int) int {    if a < b {        return a    }    return b}

func MinFloat(a, b float64) float64 {    if a < b {        return a    }    return b}

Für jeden Typ musste eine separate Funktion geschrieben werden. Mit interface{} konnte man es so machen:

func MinInterface(a, b interface{}) interface{} {    // Typumwandlung und Prüfung zur Laufzeit erforderlich    // Dies ist unsicher und ineffizient}

Die Probleme dieses Ansatzes liegen auf der Hand:

Verlust der Typsicherheit – ein Fehler kann erst zur Laufzeit auftreten.
Notwendigkeit der Typumwandlung – der Code wird umständlich.
Leistungseinbußen – die Arbeit mit Interfaces erfordert zusätzliche Operationen.

Generics lösen all diese Probleme. Sie ermöglichen:

Universelle Algorithmen einmal zu schreiben.
Strenge Typprüfung zur Kompilierzeit beizubehalten.
Auf Typumwandlungen zu verzichten und die Leistung zu steigern.

Grundlagen der Generics-Syntax in Go

Generics in Go basieren auf Typparametern. Die Syntax ist einfach und intuitiv. Typparameter werden in eckigen Klammern nach dem Funktions- oder Typnamen angegeben.

1. Einfache Funktion mit Generics

Schreiben wir dieselbe Minimum-Funktion, jetzt aber mit Generics:

package main

import "fmt"

// Min gibt den kleineren Wert von zwei zurückfunc Min[T comparable](a, b T) T {    if a < b {        return a    }    return b}

func main() {    fmt.Println(Min[int](10, 20))       // 10    fmt.Println(Min[float64](3.14, 2.71)) // 2.71    fmt.Println(Min[string]("abc", "xyz")) // abc}

Hier ist [T comparable] der Typparameter. comparable ist eine eingebaute Einschränkung (Constraint), die garantiert, dass der Typ die Vergleichsoperatoren == und != unterstützt. Beachten Sie: Für den Operator < muss die Einschränkung constraints.Ordered (aus dem Paket golang.org/x/exp/constraints) oder eine eigene verwendet werden.

2. Einschränkungen (Constraints)

Einschränkungen sind Interfaces, die definieren, welche Methoden und Operationen die Typen unterstützen müssen. In Go 1.18+ gibt es das Paket constraints (derzeit in golang.org/x/exp), aber Sie können auch eigene Einschränkungen erstellen.

import "golang.org/x/exp/constraints"

// MinOrdered funktioniert nur mit geordneten Typenfunc MinOrdered[T constraints.Ordered](a, b T) T {    if a < b {        return a    }    return b}

Eine eigene Einschränkung für Typen, die die Methode String() unterstützen: