0Pricing
TypeScript Academy · Lektion

Aufwendige Typoperationen vermeiden

Erkennen und beheben Sie tief rekursive oder distributive Typen.

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

Was macht eine Typoperation aufwendig?

Tief rekursive Typen, große Union-Distributionen und komplexe infer-Ketten zwingen TypeScript dazu, zahlreiche Typvarianten zu instanziieren, was zu exponentiellen Verlangsamungen führt.

// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;

Vermeiden Sie übermäßig große Unions

Unions mit Hunderten von Mitgliedern, beispielsweise aus vielen String-Literalen, können die Typprüfung stark verlangsamen. Erwägen Sie, den Wertebereich einzugrenzen oder string mit Validierung zu verwenden.

// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }

Bevorzugen Sie Interfaces gegenüber komplexen Typ-Aliassen

TypeScript speichert Interfaces aggressiver zwischen als komplexe Schnittmengen von Typ-Aliassen. Bevorzugen Sie interface für Objektstrukturen, auf die häufig verwiesen wird.

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

Begrenzen Sie die Rekursionstiefe

Rekursive bedingte Typen sind leistungsfähig, können aber das Tiefenlimit von TypeScript erreichen, das typischerweise bei 100 Ebenen liegt. Fügen Sie einen Tiefenzähler hinzu, um frühzeitig abzubrechen.

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

Speichern Sie Zwischentypen zwischen

Vergeben Sie Namen für komplexe Zwischentypen, damit TypeScript sie zwischenspeichern und wiederverwenden kann, anstatt sie bei jeder Referenz neu zu berechnen.

// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;

// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;

Vermeiden Sie tiefe gemappte Typen bei großen Objekten

Wenn DeepReadonly auf einen sehr großen Objekttyp angewendet wird, durchläuft TypeScript rekursiv jede Eigenschaft, was aufwendig ist.

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

Verwenden Sie eine verzögerte Auswertung von Generics

Wenn Sie einen aufwendigen Typ in einen Thunk einschließen, also einen Funktionstyp, der diesen Typ zurückgibt, wird seine Auswertung verschoben, bis der Typ tatsächlich benötigt wird.

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

Bevorzugen Sie explizite Rückgabetypen

Durch die explizite Annotation von Rückgabetypen verhindern Sie, dass TypeScript diese an jeder Aufrufstelle erneut ableiten muss, und beschleunigen dadurch die Typprüfung.

// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }

// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }

isolatedDeclarations für parallele Prüfungen

isolatedDeclarations ab TypeScript 5.5 erfordert explizite Rückgabetypen und ermöglicht die parallele Typprüfung unabhängiger Dateien ohne vollständige Typinferenz.

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

Projektverweise zur Isolation

Projektverweise verhindern, dass TypeScript unveränderte Pakete einer Typprüfung unterzieht. Das ist der größte Geschwindigkeitsgewinn bei großen Monorepos.

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

Rückblick: Aufwendige Typen vermeiden

Damit TypeScript schnell bleibt: Vermeiden Sie riesige Unions, speichern Sie Zwischentypen zwischen, bevorzugen Sie Interfaces gegenüber komplexen Aliasen, begrenzen Sie die Rekursionstiefe, verwenden Sie explizite Rückgabetypen und isolieren Sie Pakete mit Projektverweisen.

Kurzer Test

Welcher Ansatz hilft TypeScript dabei, eine Objektstruktur besonders effektiv zwischenzuspeichern?

Das haben Sie gelernt

Zu den aufwendigen TypeScript-Typoperationen gehören große Unions, tiefe Rekursion und wiederholte komplexe Inferenz. Optimieren Sie dies, indem Sie Zwischentypen zwischenspeichern, Interfaces bevorzugen, die Größe von Unions begrenzen und in Monorepos Projektverweise verwenden.

Häufig gestellte Fragen

Ist die Lektion „Aufwendige Typoperationen vermeiden“ kostenlos?

Ja — der vollständige Text von „Aufwendige Typoperationen vermeiden“ 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 „Aufwendige Typoperationen vermeiden“?

Erkennen und beheben Sie tief rekursive oder distributive Typen. 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 2 von 4.

Wie lange dauert die Lektion „Aufwendige Typoperationen vermeiden“?

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

  1. Langsame TypeScript-Kompilierung profilieren
  2. Aufwendige Typoperationen vermeiden
  3. skipLibCheck und isolierte Deklarationen
  4. Typprüfung in CI: Strategien und Werkzeuge
← Zurück zu TypeScript Academy