Seminar TypeScript Professional – Fortgeschrittenes Typsystem und Generics

Fortgeschrittene Typisierung soll Fehler verhindern und die Nutzung einer API verständlicher machen. Das Seminar entwickelt diese Fähigkeit an fachlichen Datenmodellen und wiederverwendbaren Bibliotheksfunktionen. Bestehende Typen werden nicht nur erweitert, sondern anhand konkreter Aufrufstellen, Compilerdiagnosen und Gegenbeispiele überprüft.

Neben den Sprachmitteln stehen Entwurfsentscheidungen im Mittelpunkt: Wann verbessert ein Typparameter die Beziehung zwischen Eingabe und Ausgabe? Wann wird eine bedingte Typdefinition unnötig schwer verständlich? Wann ist eine einfache Union robuster als eine weitreichende Typberechnung? Die praktische Arbeit verbindet solche Fragen mit bewusst begrenzten und wartbaren Lösungen.

Lernziele

• Generische APIs mit aussagekräftigen Constraints und stabiler Inferenz entwerfen.
• Unbekannte Werte durch nachvollziehbare Prüfungen auf konkrete Typen eingrenzen.
• Typen mit keyof, indiziertem Zugriff, Mapped Types und Conditional Types ableiten.
• Zustände und vollständige Fallunterscheidungen mit diskriminierten Unions modellieren.
• Komplexe Typdefinitionen mit Gegenbeispielen prüfen und auf verständliche Alternativen reduzieren.

Zielgruppe

TypeScript-Entwickler mit praktischer Erfahrung, Bibliotheksautoren und Entwickler gemeinsam genutzter APIs.

Voraussetzungen

Sicherer Umgang mit grundlegenden Typen, Funktionen, Interfaces, Union Types und ES-Modulen; erste Erfahrungen mit Generics. Empfohlen: Grundlagen und Sprachpraxis.

Inhaltsübersicht

1. Typbeziehungen und Narrowing
2. Generische Funktionen und Verträge
3. Typen aus vorhandenen Modellen ableiten
4. Bedingte Typen und Inferenz
5. Tupel, Zeichenketten und API-Design
6. Typprüfungen und Entwurfsreview

Seminarinhalte

Typbeziehungen und Narrowing

• Strukturelle Kompatibilität, Literaltypen und Widening anhand von Zuweisungen untersuchen.
• unknown, any, never und void nach ihrer jeweiligen Bedeutung unterscheiden.
• Kontrollflussanalyse, Typprädikate und Assertion Functions nachvollziehbar einsetzen.
• Diskriminierte Unions und vollständige Fallunterscheidungen für fachliche Zustände entwickeln.

Generische Funktionen und Verträge

• Beziehungen zwischen Parametern und Rückgabewerten mit Typparametern ausdrücken.
• Constraints, Standardtypparameter und kontextuelle Inferenz an Aufrufstellen prüfen.
• Funktionsüberladungen, Union-Parameter und Generics anhand derselben Anforderung vergleichen.
• Unnötige Typparameter und scheinbar sichere Type Assertions im API-Entwurf erkennen.

Typen aus vorhandenen Modellen ableiten

• keyof, typeof und indizierte Zugriffstypen zu Modelltransformationen kombinieren.
• Mapped Types einschließlich Modifikatoren und Key Remapping entwickeln.
• Utility Types für Auswahl, Ausschluss, optionale Werte und Unveränderlichkeit einsetzen.
• satisfies und const Assertions nutzen, ohne Laufzeitvalidierung vorzutäuschen.

Bedingte Typen und Inferenz

• Conditional Types für nachvollziehbare Fallunterscheidungen auf Typebene verwenden.
• infer zum Herauslösen von Typanteilen aus Funktionen und Datenstrukturen einsetzen.
• Distributives Verhalten bei Unions erkennen und bei Bedarf bewusst unterbinden.
• Rekursive Typen begrenzen und Compilerdiagnosen als Hinweis auf Modellkomplexität auswerten.

Tupel, Zeichenketten und API-Design

• Variadische Tupel für Parameterlisten und Funktionskomposition verwenden.
• Template Literal Types auf klar begrenzte Ereignis- und Schlüsselmodelle anwenden.
• Readonly-Verträge und deren flache statische Wirkung gegenüber Laufzeitmutationen einordnen.
• Einen typsicheren Ereignisverteiler mit aussagekräftigen Fehlermeldungen gestalten.

Typprüfungen und Entwurfsreview

• Gültige und ungültige Verwendungen einer öffentlichen API als Typprüffälle festhalten.
• Erwartete Compilerfehler gezielt mit @ts-expect-error absichern.
• Schwer lesbare Typberechnungen durch benannte Zwischentypen oder einfachere Verträge ersetzen.
• API-Entwürfe nach Inferenz, Verständlichkeit, Fehlermeldungen und Prüfdauer vergleichen.

Praxisprojekt

Die praktische Arbeit folgt einer zusammenhängenden Aufgabenstellung. Die folgenden Schritte werden anhand vorbereiteter Ausgangsstände umgesetzt und mit überprüfbaren Zwischenständen verbunden.

1. Ein fachliches Ereignismodell mit zulässigen Ereignisnamen und Nutzdaten definieren.
2. Eine generische Registrierung entwickeln, die Ereignisname und Handler-Nutzdaten verknüpft.
3. Hilfstypen aus dem Ereignismodell ableiten und Inferenz an mehreren Aufrufstellen kontrollieren.
4. Fehlerhafte Ereignisse und Handler als negative Typprüffälle ergänzen.
5. Einen absichtlich überkomplexen Typausdruck durch eine verständlichere Variante ersetzen.
6. Die API anhand der Compilerdiagnosen und ihrer Nutzung durch ein zweites Modul bewerten.

Schulungsumgebung

Vorbereitetes TypeScript-Repository mit isolierten Typprüfdateien, Editorunterstützung und automatisierter Compilerprüfung; keine Frameworkkenntnisse erforderlich.

Die Schulungsumgebung wird vom Kunden nach der vorab abgestimmten technischen Checkliste bereitgestellt. Benötigte Installationsrechte, Werkzeuge und Übungsstände werden vor Seminarbeginn geprüft.