TypeScript Academy · Lektion

Zählen mit der Tupellänge

Repräsentieren Sie Zahlen in Typen als Tupellängen.

Zählen mit der Tupellänge ist eine kostenlose TypeScript 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 TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Zahlen brauchen eine Darstellung

Das Typsystem kann numerische Literale nicht direkt addieren. Die klassische Lösung besteht darin, eine Zahl N als Tupel mit N Elementen darzustellen. Der Inhalt ist unerheblich; nur die Länge zählt.

type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3

Länge auslesen

Jeder Tupeltyp verfügt über eine length-Eigenschaft, die ein numerischer Literaltyp ist. Durch den Zugriff mit ["length"] wird sie wieder als Zahl ausgelesen, die Sie verwenden können.

type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"];           // 0
type C = ["x"]["length"];        // 1

Warum unknown als Platzhalter

Wir verwenden unknown als Elementtyp, weil die Werte irrelevant sind und nur die Anzahl zählt. Jeder Typ würde funktionieren, aber unknown macht deutlich, dass es sich um einen „Platzhalter“ handelt.

type Two = [unknown, unknown];
type N = Two["length"]; // 2

Ein Tupel der Länge N erstellen

Für den umgekehrten Weg erstellen Sie mithilfe von Rekursion ein Tupel mit einer bestimmten Ziellänge. Fügen Sie Elemente hinzu, bis die Länge N entspricht, und geben Sie anschließend das Tupel zurück. Dies ist der bekannte Hilfstyp BuildTuple.

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

type A = BuildTuple<3>; // [unknown, unknown, unknown]

So funktioniert die Schleife von BuildTuple

Verfolgen wir BuildTuple<3>:

Akkumulatorlänge 0, nicht 3, ein Element hinzufügen
Akkumulatorlänge 1, nicht 3, ein Element hinzufügen
Akkumulatorlänge 2, nicht 3, ein Element hinzufügen
Akkumulatorlänge 3, entspricht 3, zurückgeben

Die Länge des Akkumulators ist der Schleifenzähler.

type A = BuildTuple<2>; // [unknown, unknown]

Die Länge ist die Brücke

Zwei Operationen ermöglichen den Wechsel zwischen Zahlen und Tupeln:

Zahl zu Tupel: BuildTuple<N>
Tupel zu Zahl: T["length"]

Die gesamte Typarithmetik baut auf dem Überqueren dieser Brücke auf.

type FromN = BuildTuple<4>;        // tuple of length 4
type BackToN = FromN["length"];    // 4

Vergleichen anhand der Länge

Da die Tupellänge ein Literal ist, können Sie die Gleichheit von Anzahlen prüfen. Erstellen Sie Tupel und vergleichen Sie ihre Längen über Zuweisbarkeit.

type SameLength<A extends unknown[], B extends unknown[]> =
  A["length"] extends B["length"] ? true : false;

type X = SameLength<[1, 2], ["a", "b"]>;   // true
type Y = SameLength<[1], ["a", "b"]>;      // false

Ein generischer Längenzähler

Sie können length mithilfe von Rekursion nachbilden, um die Funktionsweise zu verstehen, auch wenn das Auslesen mit ["length"] schneller ist. Das zeigt, dass Zählen lediglich bedeutet, ein Tupel zu durchlaufen.

type Len<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Len<R, [...Acc, unknown]>
    : Acc["length"];

type A = Len<["a", "b", "c"]>; // 3

Tupel als Zähler

Stellen Sie sich das Tupel als Strichliste vor: Jedes Element ist ein Strich. Ein Element hinzuzufügen erhöht den Zähler, eines zu entfernen verringert ihn. Dieses Denkmodell macht die Arithmetik intuitiv.

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

type A = Inc<3>; // 4

Ausblick auf das Dekrementieren

Beim Dekrementieren wird zunächst das Tupel für N erstellt. Anschließend wird alles außer dem letzten Element inferiert und die kürzere Länge ausgelesen. Im nächsten Kurs werden Sie dies formal umsetzen.

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

type A = Dec<3>; // 2
type B = Dec<0>; // 0

Zu beachtende Grenzen

Diese Technik funktioniert für kleine nichtnegativer ganze Zahlen. Bei einem sehr großen N werden die Rekursionsgrenzen erreicht, und für negative Zahlen oder Dezimalzahlen gibt es keine integrierte Unterstützung. Innerhalb dieser Grenzen ist die Technik zuverlässig und vollständig statisch.

type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deep

Schnelltest

Testen Sie Ihr Verständnis des Zählens anhand von Tupellängen.

Zusammenfassung

Zählen ist die Grundlage der Typarithmetik.

Stellen Sie N als Tupel der Länge N dar.
Lesen Sie die Zahl mit T["length"] aus.
BuildTuple<N> wandelt eine Zahl in ein Tupel um.
Funktioniert nur für kleine nichtnegative ganze Zahlen.

Als Nächstes: echte Addition und Subtraktion.

Häufig gestellte Fragen

Ist die Lektion „Zählen mit der Tupellänge“ kostenlos?

Ja — der vollständige Text von „Zählen mit der Tupellänge“ 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 „Zählen mit der Tupellänge“?

Repräsentieren Sie Zahlen in Typen als Tupellängen. 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 1 von 4.

Wie lange dauert die Lektion „Zählen mit der Tupellänge“?

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