TypeScript Academy · Lektion

Typen als Berechnungssprache

Verstehen Sie das Typsystem als rein funktionale Sprache.

Typen als Berechnungssprache 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.

Typen sind eine Sprache

TypeScript enthält zwei Sprachen, die nebeneinander bestehen. Die eine ist das JavaScript auf Werteebene, das Sie bereits kennen. Die andere ist die Typebene, die vollständig zur Kompilierzeit ausgeführt wird. In diesem Kurs lernen Sie, in dieser zweiten Sprache zu programmieren.

Das Typsystem ist eine kleine, reine, funktionale Sprache. Sie geben ihm Typen als Eingabe, und es berechnet daraus Typen als Ausgabe. Nichts davon bleibt zur Laufzeit erhalten.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Typen hinein, Typen heraus

Ein generischer Typ ist im Wesentlichen eine Funktion von Typen zu Typen. Der Typparameter ist das Argument, und der Rumpf ist der Rückgabewert.

Im folgenden Beispiel nimmt Boxed einen Typ T entgegen und erzeugt einen Objekttyp, der ihn umschließt. Stellen Sie sich T als Parameter vor, den Sie übergeben.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

Generics sind Funktionen

Vergleichen Sie eine Funktion auf Wertebene mit einer Funktion auf Typebene. Die Strukturen sind nahezu identisch: Parameter hinein, ein einzelnes Ergebnis heraus.

Wert: const id = (x) => x
Typ: type Id<T> = T

Die Id auf Typebene gibt einfach zurück, was Sie ihr übergeben.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Keine Kosten zur Laufzeit

Alles auf Typebene wird entfernt, bevor Ihr Code ausgeführt wird. Die JavaScript-Ausgabe enthält keinerlei Spuren Ihrer Typberechnungen. Das laufende Programm verursacht unabhängig davon, wie aufwendig Ihre Typen sind, keine Performancekosten.

Deshalb wird Programmierung auf Typebene manchmal als kostenlos bezeichnet: Sie wirkt sich nur auf den Compiler aus, niemals auf das Bundle.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Mehrere Parameter

Funktionen auf Typebene können wie gewöhnliche Funktionen mehrere Parameter entgegennehmen. Hier nimmt Merge zwei Objekttypen entgegen und kombiniert sie.

Lesen Sie es so: Gegeben A und B wird ein Objekt zurückgegeben, das alle Eigenschaften beider Typen enthält.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Standardwerte für Parameter

Typparameter können Standardwerte haben, genau wie Standardargumente von Funktionen. Wenn der Aufrufer das Argument weglässt, wird der Standardwert verwendet.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

Constraints als Schutzmechanismen

Ein Constraint mit extends schränkt ein, welche Typen übergeben werden dürfen. Er entspricht auf Typebene der Validierung eines Funktionsarguments, bevor es verwendet wird.

HasId akzeptiert nur Typen, die bereits über eine id-Eigenschaft verfügen, sodass der Rumpf sicher darauf zugreifen kann.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Berechnung statt bloßer Annotation

Anfänger verwenden Typen nur, um Werte zu beschriften. Bei der Programmierung auf Typebene werden Typen verwendet, um Ergebnisse zu berechnen. Das integrierte Hilfsmittel ReturnType untersucht beispielsweise einen Funktionstyp und extrahiert dessen Ergebnistyp.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Eigenschaften abbilden

Gemappte Typen ermöglichen es Ihnen, jede Eigenschaft eines Objekttyps zu transformieren. Das entspricht einer Schleife in der Typsprache. Stringify wandelt jeden Werttyp in string um.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Rein und deterministisch

Die Typsprache ist rein: Dieselben Eingaben erzeugen immer denselben Ausgabetyp, ohne Seiteneffekte. Es gibt keine Mutation, kein I/O und keinen Zeitbezug. Diese Reinheit macht Programme auf Typebene vorhersehbar und kombinierbar.

Dank dieser Reinheit können Sie über Typen genauso nachdenken wie über Mathematik: durch Einsetzen.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Warum das wichtig ist

Wenn Sie diese zweite Sprache beherrschen, können Sie Regeln ausdrücken, die der Compiler automatisch durchsetzt: gültige Routen, vollständige switch-Anweisungen, sichere String-Manipulation und APIs, die sich nicht falsch verwenden lassen. Im restlichen Kurs bauen Sie sich dafür das nötige Werkzeug auf.

Wichtige Denkweise: Ein Typ ist ein Wert in der Typsprache, und ein Generic ist eine Funktion.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Schnelltest

Überprüfen Sie Ihr Verständnis von Typen als Berechnungssprache.

Zusammenfassung

Sie haben gelernt, dass TypeScript-Typen eine rein funktionale Sprache bilden, die zur Compilezeit ausgeführt wird.

Generics sind Funktionen: Typen hinein, Typen hinaus.
Parameter unterstützen Standardwerte und extends-Constraints.
Gemappte Typen durchlaufen Eigenschaften.
Alles wird entfernt, sodass keine Laufzeitkosten entstehen.

Als Nächstes geben Sie dieser Sprache eine if-Anweisung: bedingte Typen.

Häufig gestellte Fragen

Ist die Lektion „Typen als Berechnungssprache“ kostenlos?

Ja — der vollständige Text von „Typen als Berechnungssprache“ 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 „Typen als Berechnungssprache“?

Verstehen Sie das Typsystem als rein funktionale Sprache. 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 „Typen als Berechnungssprache“?

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