TypeScript Academy · Lektion

Vergleiche auf Typebene

Vergleichen Sie Zahlen vollständig auf Typebene.

Vergleiche auf Typebene ist eine kostenlose TypeScript 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 TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Zahlen vergleichen

Um numerische Literaltypen zu vergleichen, greifen Sie erneut auf Tupel zurück. Die Idee: Beide Zahlen werden im Gleichschritt verkleinert, und Sie prüfen, welche zuerst null erreicht. Die Zahl, deren Tupel zuerst leer ist, ist die kleinere.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

Gleichheit von Literalen

Die Gleichheit numerischer Literale wird über gegenseitige Zuweisbarkeit geprüft. Zwei Literale sind gleich, wenn sich jedes auf das andere erstreckt. Das Einschließen in Tupel verhindert unerwartete Effekte bei Vereinigungen.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Größer als durch Verkleinern

Für A > B erstellen Sie für beide Zahlen Tupel und entfernen in jedem Schritt aus beiden ein Element. Wenn B zuerst leer ist, während A noch Elemente enthält, ist A größer.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

So ist das Muster zu lesen

Das Muster [...BuildTuple<B>, unknown, ...unknown[]] bedeutet: ein Präfix der Länge B, gefolgt von mindestens einem weiteren Element. Wenn A diesem Muster entspricht, hat A mehr Elemente als B, also gilt A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Kleiner als

LessThan ist einfach GreaterThan mit vertauschten Argumenten. Verwenden Sie vorhandene Logik wieder, statt sie neu herzuleiten.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Größer oder gleich

Kombinieren Sie den Vergleich mit der Gleichheit. A >= B ist wahr, wenn A > B oder A == B gilt.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Rekursiver Vergleich

Eine Alternative vergleicht Zahlen, indem beide dekrementiert werden, bis eine davon null erreicht. Dadurch wird die Gleichschritt-Idee ausdrücklich sichtbar: Die Zahl, die zuerst null erreicht, ist die kleinere.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

Die Abhängigkeit von Dec

Die rekursive Variante benötigt Dec aus der vorherigen Lektion. In jedem Schritt wird von jeder Seite ein Strich entfernt. Wenn beide null sind, sind sie gleich; wenn nur eine null ist, ist die andere größer.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

Gleichheit und Zuweisbarkeit

Seien Sie vorsichtig: number extends number ist wahr, bedeutet aber nicht die Gleichheit von Literalen. Die Vergleiche hier setzen spezifische Literaltypen wie 3 und 5 voraus, nicht den weit gefassten Typ number.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Einen Sortierschlüssel erstellen

Mit Vergleichen können Sie Sortierregeln auf Typebene festlegen. Sie können beispielsweise auf Typebene bestimmen, ob ein Tupel aus zwei Zahlen aufsteigend sortiert ist.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Sparsam verwenden

Vergleiche kosten Rekursion. Sie eignen sich hervorragend, um kleine begrenzte Werte abzusichern (Indizes, feste Grenzen), sind aber keine allgemeine numerische Bibliothek. Halten Sie die Operanden klein und bevorzugen Sie die Präfix-Musterform, die weniger Rekursionstiefe benötigt als eine vollständige Rekursion im Gleichschritt.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Schnelltest

Testen Sie Ihr Verständnis von Vergleichen auf Typebene.

Zusammenfassung

Sie können Zahlen nun im Typsystem ordnen.

Gleichheit über gegenseitige Zuweisbarkeit von Literalen.
GreaterThan über ein Präfix der Länge B plus ein zusätzliches Element.
LessThan vertauscht die Argumente; Gte ergänzt die Gleichheit.
Funktioniert mit kleinen Literalzahlen, nicht mit dem weit gefassten Typ number.

Als Nächstes: All dies in praktische Hilfstypen umwandeln.

Häufig gestellte Fragen

Ist die Lektion „Vergleiche auf Typebene“ kostenlos?

Ja — der vollständige Text von „Vergleiche auf Typebene“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Vergleiche auf Typebene“?

Vergleichen Sie Zahlen vollständig auf Typebene. Du übst TypeScript 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 TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript 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 „Vergleiche auf Typebene“?

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 TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript 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 TypeScript Academy