Go Academy · Lektion

Constraints: comparable und Interfaces

Union-Constraints und der integrierte Typ comparable

Constraints: comparable und Interfaces ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Was ist eine Constraint?

Eine Constraint schränkt ein, welche Typen als Typargument verwendet werden können. Ohne Constraint ist der Typparameter any (das leere Interface – es unterstützt nur Zuweisung und Vergleich über ==).

Die any-Constraint

any (Alias für interface{}) ist die weiteste Constraint – alle Typen erfüllen sie. Sie können nur Operationen verwenden, die alle Typen unterstützen: Zuweisung und Übergabe an Interface-Parameter.

func Print[T any](v T) { fmt.Println(v) }

Die comparable-Constraint

comparable beschränkt den Typparameter auf Typen, die == und != unterstützen. Sie ist erforderlich, wenn der Typ als Map-Schlüssel oder in Gleichheitsprüfungen verwendet werden soll.

func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v { return true }
    }
    return false
}

Interface-Constraints

Verwenden Sie ein Interface als Constraint, um bestimmte Methoden vorauszusetzen. Der Typparameter muss alle Methoden des Interfaces besitzen.

type Stringer interface { String() string }

func Print[T Stringer](v T) {
    fmt.Println(v.String())
}

Union-Constraints

Verwenden Sie mit | eine Vereinigung von Typen, um auf eine Gruppe konkreter Typen zu beschränken. Dadurch können Sie Operatoren (wie +) verwenden, die nicht Bestandteil eines Interfaces sind.

type Number interface {
    int | int64 | float64
}

func Sum[T Number](s []T) T {
    var total T
    for _, v := range s { total += v }
    return total
}

~T für zugrunde liegende Typen

Verwenden Sie ~T, um nicht nur T, sondern alle Typen einzuschließen, deren zugrunde liegender Typ T ist (z. B. benutzerdefinierte Typen, die mit type MyInt int definiert wurden).

type Integer interface { ~int | ~int64 }

type MyInt int
// MyInt satisfies Integer because its underlying type is int

golang.org/x/exp/constraints

Das Paket constraints stellt gängige Constraint-Interfaces bereit: Ordered (unterstützt <), Integer, Float, Signed, Unsigned.

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

func Min[T constraints.Ordered](a, b T) T {
    if a < b { return a }
    return b
}

Paket cmp (Go 1.21)

Go 1.21 hat das Constraint cmp.Ordered sowie die Funktionen cmp.Compare/cmp.Less in der Standardbibliothek eingeführt und damit die Abhängigkeit von exp/constraints ersetzt.

import "cmp"
func Min[T cmp.Ordered](a, b T) T { return min(a, b) }

Constraints kombinieren

Betten Sie mehrere Interfaces in ein Constraint ein, um mehrere Eigenschaften vorauszusetzen:

type Printable interface {
    comparable
    fmt.Stringer
}

Constraint-Inferenz

Der Compiler leitet Typparameter aus den Argumenten ab. Wenn das Constraint zu weit gefasst ist (any), müssen Sie möglicherweise explizite Typargumente angeben, um die Inferenz zu steuern.

Wann comparable verwendet wird

Verwenden Sie comparable, wenn die generische Funktion für Werte == verwenden, sie als Schlüssel in Maps speichern oder als Elemente von Maps bzw. Sets nutzen muss. Nicht alle Typen sind vergleichbar (Slices, Maps und Funktionen sind es nicht).

Schnelltest

Was bedeutet das Präfix ~ in einem Union-Constraint wie ~int?

Zusammenfassung: Constraints

Wichtige Punkte:

any: am weitesten gefasst; comparable: unterstützt ==; interface: setzt Methoden voraus
Union (int|float64) ermöglicht arithmetische Operatoren
~T schließt benannte Typen ein, deren zugrunde liegender Typ T ist
cmp.Ordered (ab Go 1.21) für Constraints mit <, >, <=, >=

Häufig gestellte Fragen

Ist die Lektion „Constraints: comparable und Interfaces“ kostenlos?

Ja — der vollständige Text von „Constraints: comparable und Interfaces“ 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 „Constraints: comparable und Interfaces“?

Union-Constraints und der integrierte Typ comparable 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 2 von 4.

Wie lange dauert die Lektion „Constraints: comparable und Interfaces“?

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