Go Academy · Lektion

Syntax von Typparametern

Generische Funktionen und Typen mit [T any]

Syntax von Typparametern ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Hintergrund zu Generics

Vor Go 1.18 erforderte Code, der mit mehreren Typen funktionierte, entweder interface{}/any (wodurch Typsicherheit verloren ging) oder Codegenerierung. Generics fügen Typparameter für Polymorphie zur Compilezeit hinzu.

Syntax generischer Funktionen

Geben Sie Typparameter in eckigen Klammern nach dem Funktionsnamen an:

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

Typermittlung

Der Compiler ermittelt die Typargumente in den meisten Fällen aus den Funktionsargumenten. Wenn die Ermittlung fehlschlägt, können Sie sie explizit angeben.

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

Generische Typen

Auch Structs und andere Typen können Typparameter haben:

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
}

Mehrere Typparameter

Funktionen und Typen können mehrere Typparameter haben:

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
}

Nullwert eines Typparameters

Deklarieren Sie mit var zero T eine Variable mit dem Nullwert. Das ist erforderlich, wenn eine generische Funktion ein Ergebnis ohne Wert zurückgeben soll.

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

Methoden generischer Typen

Methoden eines generischen Typs verwenden die Typparameter des Typs, nicht eigene. Eine Methode kann keine zusätzlichen Typparameter einführen.

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

Instanziierung

Die Verwendung eines generischen Typs mit einem konkreten Typargument wird als Instanziierung bezeichnet. Sie erfolgt zur Compilezeit, nicht zur Laufzeit – es entsteht kein Boxing-Overhead.

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

Typaliase und generische Typen

Sie können Typaliase für instanziierte generische Typen erstellen:

type IntStack = Stack[int]

Einschränkungen

Typparameter können nicht mit Type-Switches oder Type Assertions verwendet werden. Methoden generischer Typen können keine zusätzlichen Typparameter haben. Generics können ohne Constraints nicht für operatorüberladene Typen verwendet werden.

Wann Sie Generics verwenden sollten

Verwenden Sie Generics für wirklich typunabhängige Algorithmen (Container-Typen, funktionale Hilfsfunktionen wie Map/Filter/Reduce), wenn die Alternative in doppeltem Code oder unsicheren Casts bestünde.

Kurze Überprüfung

Wo werden Typparameter in einer generischen Funktion deklariert?

Zusammenfassung: Syntax von Typparametern

Wichtige Punkte:

Typparameter in eckigen Klammern: func Foo[T any](...)
Funktioniert mit Funktionen und Typen (Structs usw.)
Der Compiler ermittelt Typargumente in den meisten Fällen aus den Argumenten
Nullwert: var zero T; keine Typparameter auf Methodenebene

Häufig gestellte Fragen

Ist die Lektion „Syntax von Typparametern“ kostenlos?

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

Generische Funktionen und Typen mit [T any] 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 1 von 4.

Wie lange dauert die Lektion „Syntax von Typparametern“?

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