TypeScript Academy · Lektion

Praktische numerische Typ-Utilities

Wenden Sie Typarithmetik auf Bereichs- und Längenbeschränkungen an.

Praktische numerische Typ-Utilities ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Von der Theorie zu Werkzeugen

Arithmetik und Vergleiche werden nützlich, wenn sie als praktische Hilfstypen verpackt werden: Wertebereiche, Arrays mit erzwungener Länge und begrenzte Indizes. In dieser Lektion werden aus den Grundelementen Dinge, die Sie tatsächlich ausliefern würden.

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

Aufzählung: 0 bis N-1

Ein grundlegender Hilfstyp erzeugt eine Vereinigung aller Zahlen von 0 bis N-1. Erstellen Sie ein Tupel der Länge N und lesen Sie jeden Schlüsselindex aus.

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

type A = Enumerate<4>; // 0 | 1 | 2 | 3

Wertebereichstypen

Ein Range<Start, End> liefert die Zahlen von Start bis einschließlich End - 1. Verwenden Sie Enumerate<End> und schließen Sie die Werte unterhalb von Start aus.

type Range<S extends number, E extends number> =
  Exclude<Enumerate<E>, Enumerate<S>>;

type A = Range<2, 6>; // 2 | 3 | 4 | 5

Einen Parameter einschränken

Verwenden Sie einen Wertebereich, um gültige Argumente einzuschränken. Eine Funktion, die nur einen kleinen Würfelwurf akzeptiert, kann Range<1, 7> annehmen, sodass der Compiler Werte außerhalb des gültigen Bereichs ablehnt.

type DiceFace = Range<1, 7>; // 1|2|3|4|5|6
declare function roll(face: DiceFace): void;
roll(4); // ok
// roll(8); // compile error

Array-Länge erzwingen

Ein Arraytyp mit fester Länge lehnt Arrays mit der falschen Größe ab. Erstellen Sie mithilfe von Rekursion ein Tupel aus N Elementen des Typs T.

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

type RGB = FixedArray<number, 3>; // [number, number, number]

Feste Längen verwenden

Fehlverwendung führt nun zu einem Kompilierungsfehler. Ein Punkt im 3D-Raum muss genau drei Koordinaten haben.

type Vec3 = FixedArray<number, 3>;
const v: Vec3 = [1, 2, 3]; // ok
// const w: Vec3 = [1, 2]; // error: missing element

Indizes begrenzen

Sie können einen Indextyp auf gültige Arraypositionen begrenzen. Kombinieren Sie eine Tupellänge mit Enumerate, sodass nur Indizes innerhalb der Grenzen akzeptiert werden.

type Indices<T extends readonly unknown[]> = Enumerate<T["length"]>;

type Arr = readonly ["a", "b", "c"];
type I = Indices<Arr>; // 0 | 1 | 2

Sicherer Zugriff über Indizes

Mit einem gültigen Indextyp können Sie einen Getter schreiben, dessen Indexparameter nicht außerhalb der Grenzen liegen kann. So werden Fehler durch falsche Endpunkte bereits beim Kompilieren erkannt.

declare function at<T extends readonly unknown[]>(
  arr: T,
  i: Indices<T>
): T[Indices<T>];

const x = at(["a", "b", "c"] as const, 2); // ok
// at(["a", "b", "c"] as const, 3); // error

Hilfstypen für Min und Max

Setzen Sie einen Vergleich darauf auf, um die größere oder kleinere von zwei Zahlen auszuwählen – nützlich, um einen Wert auf einen Wertebereich zu begrenzen.

type Max<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? A : B;
type Min<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? B : A;

type X = Max<3, 8>; // 8
type Y = Min<3, 8>; // 3

Hilfstypen kombinieren

Diese Hilfstypen lassen sich kombinieren. Ein Tupel mit einer Länge innerhalb eines Wertebereichs, ein auf sein Array begrenzter Index, ein durch Min und Max beschränkter Wert: Jeder davon ist eine kleine, wiederverwendbare Funktion auf Typebene.

type ValidPort = Range<1, 4>; // 1 | 2 | 3 (toy example)
type Slots = FixedArray<ValidPort, 2>; // [1|2|3, 1|2|3]

Wann es sich lohnt

Typarithmetik spielt ihre Stärken bei kleinen, festen Grenzen aus: RGB-Tupel, Würfelseiten, Brettkoordinaten und Feldgrößen in Protokollen. Für große oder dynamische Zahlen lohnt sie sich nicht, da Rekursionsgrenzen und Komplexität den Sicherheitsgewinn überwiegen. Setzen Sie sie ein, wenn die Grenze klein und die Garantie wertvoll ist.

type Board = FixedArray<FixedArray<0 | 1, 3>, 3>; // 3x3 grid

Schnelltest

Testen Sie Ihr Verständnis praktischer numerischer Hilfstypen.

Zusammenfassung

Sie haben eine kleine Bibliothek numerischer Hilfstypen erstellt.

Enumerate und Range erzeugen Zahlenvereinigungen.
FixedArray erzwingt exakte Längen.
Indices begrenzt Zugriffe auf gültige Positionen.
Min/Max begrenzen Werte.

Verwenden Sie sie für kleine feste Grenzen. Als Nächstes in Kurs 23: höherkindige Typen simulieren.

Häufig gestellte Fragen

Ist die Lektion „Praktische numerische Typ-Utilities“ kostenlos?

Ja — der vollständige Text von „Praktische numerische Typ-Utilities“ 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 „Praktische numerische Typ-Utilities“?

Wenden Sie Typarithmetik auf Bereichs- und Längenbeschränkungen an. 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 4 von 4.

Wie lange dauert die Lektion „Praktische numerische Typ-Utilities“?

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