Bitte wählen Sie die Bereiche, die Sie exportieren möchten:
Schulung TypeScript 5.x Workshop
Hands-on-Vertiefung: Decorators, Generics, Type-Level Patterns und moderne Projektarchitektur
Schulungsformen
Inhouse-/Firmenschulung
- 3 Tage - anpassbar
- Termin nach Wunsch
- In Ihrem Hause oder bei der GFU
- Preis nach Angebot
- Lernumgebung in der Cloud
- Inhalte werden auf Wunsch an die Anforderungen Ihres Teams angepasst.
Individualschulung
- 3 Tage - anpassbar
- Termin nach Wunsch
- In Ihrem Hause oder bei der GFU
- Preis nach Angebot
- Lernumgebung in der Cloud
- 1 Teilnehmender = Fokus aufs Fachliche und maximaler Raum für individuelle Fragen.
Beschreibung
Gleichzeitig bleiben die fortgeschrittenen Patterns des Typsystems - Discriminated Unions, Mapped Types, Conditional Types, Template Literal Types - für viele Entwickler ein Buch mit sieben Siegeln. Sie nutzen TypeScript auf 30 % Kapazität: Grundtypen, einfache Interfaces, gelegentlich ein Generic. Die restlichen 70 % - die Patterns, die Framework-APIs elegant machen, die Fehler unmöglich statt nur unwahrscheinlich machen - bleiben ungenutzt.
Dieses Workshop-Seminar schließt diese Lücke. Drei Tage, überwiegend Praxis: jedes Thema beginnt mit einem Problem aus der realen Entwicklung, und die Lösung ist ein TypeScript-Pattern, das sofort im eigenen Projekt einsetzbar ist.
Entdecken Sie auch unsere anderen TypeScript Weiterbildungen.
Schulungsziel
Jede teilnehmende Person verlässt das Seminar mit der produktiven Beherrschung der TypeScript-5.x-Features (satisfies, Stage-3-Decorators, const Type Parameters), der Fähigkeit, fortgeschrittene Patterns einzusetzen (Discriminated Unions, Branded Types, Result-Monad, Builder Pattern), eigenen Utility Types als wiederverwendbare Bibliothek, dem Verständnis von Runtime-Validierung mit Zod an System-Grenzen, einem typsicheren Projektgerüst mit modernen Architektur-Patterns und der Code-Review-Kompetenz für TypeScript-Projekte.
Details
Inhalt
1. TypeScript 5.x: Neue Features und Migration
- Ziele und Erwartungen der Teilnehmenden
- Klärung individueller Lernziele und Erwartungen für ein praxisnahes und relevantes Seminar
- satisfies-Operator: Typ prüfen, ohne den inferierten Typ zu überschreiben - das fehlende Puzzlestück zwischen Annotation und Inference. Praxis-Problem: Konfigurationsobjekt soll einem Schema entsprechen, aber die Literal-Typen der Werte beibehalten.
- const Type Parameters: generische Funktionen, die Literal-Typen statt geweiteter Typen inferieren. Praxis-Problem: eine Routing-Funktion, die den exakten Pfad-String als Typ beibehält.
- Stage-3-Decorators: der neue Standard, der experimentalDecorators ablöst. Unterschiede zum Legacy-Standard, Migration bestehender Decorators, Class Decorators, Method Decorators, Field Decorators.
- Weitere 5.x-Features: verbesserte Enum-Behandlung, moduleResolution: bundler, verbatimModuleSyntax, isolatedDeclarations, tsconfig extends von mehreren Dateien.
- Praxis-Übung: Bestehendes Projekt von TypeScript 4.x auf 5.x migrieren: satisfies einsetzen, Legacy-Decorators auf Stage 3 umstellen, tsconfig modernisieren.
- Discriminated Unions als Zustandsmaschine: Anwendungszustände so modellieren, dass ungültige Kombinationen zur Compile-Time unmöglich sind. Exhaustiveness-Prüfung mit never.
- Praxis-Pattern: Formular-State (Idle -> Validating -> Submitting -> Success | Error), API-Response (Loading | Success | Error), Permission-System (Admin | Editor | Viewer - jede Rolle hat andere verfügbare Aktionen).
- Type Narrowing in der Tiefe: typeof, instanceof, in, Custom Type Guards, Assertion Functions. Narrowing in verschachtelten Strukturen.
- Praxis-Übung: Typsichere State Machine für einen Checkout-Prozess: 6 Zustände, Übergänge als Funktionen typisiert, ungültige Übergänge sind Compile-Time-Fehler.
- Generics als Abstraktionswerkzeug: nicht nur Container<T>, sondern Funktionen, die Beziehungen zwischen Eingabe- und Ausgabetypen ausdrücken. Mehrere Typ-Parameter, Constraints mit extends, keyof-Patterns.
- Praxis-Pattern: typsicherer Property-Zugriff (pluck<T, K extends keyof T>(obj: T, key: K): T[K]), generische Factory Functions, generische Event-Handler mit EventMap.
- Conditional Types und infer: Typ-Logik und Typ-Extraktion. ReturnType, Parameters, Awaited selbst nachbauen.
- Praxis-Übung: Generisches Validierungs-Framework: Schema<T> definiert Validierungsregeln pro Property von T, validate<T>(data: unknown, schema: Schema<T>): T - mit Typ-Inference und Fehler-Reporting.
4. Utility Types meistern und eigene bauen
- Eingebaute Utility Types produktiv einsetzen: Partial, Required, Pick, Omit, Record, Readonly, ReturnType, Parameters, Awaited, NoInfer. Praxis-Pattern: API-DTOs ableiten statt manuell duplizieren (CreateDTO = Omit<Entity, 'id' | 'createdAt'>, UpdateDTO = Partial<CreateDTO>).
- Mapped Types: eigene Transformationen mit { [K in keyof T]: ... }. Modifier (+/- readonly, +/- optional). Key Remapping mit as.
- Template Literal Types: String-Manipulation auf Typ-Ebene für typsichere Event-Namen, CSS-Klassen, API-Routen. Intrinsic String Types (Capitalize, Uncapitalize, Uppercase, Lowercase).
- Praxis-Übung: 5 eigene Utility Types für ein reales Projekt: DeepPartial<T>, StrictOmit<T, K> (Compile-Fehler wenn K kein Key von T ist), EventHandlerMap<Events> (aus Event-Union automatisch on-Handler-Typen generieren), PathsOf<T> (alle verschachtelten Pfade als Union: 'user.address.city'), ApiRoutes als Template Literal Type.
- Branded Types: nominale Typisierung simulieren - UserId und ProductId sind beide string, aber nicht austauschbar. Für: IDs, Einheiten (Meter vs. Kilometer), validierte Strings (E-Mail, URL).
- Builder Pattern mit Generics: der Typ erweitert sich mit jedem Methodenaufruf - nur vollständig konfigurierte Objekte können gebaut werden.
- Result<T, E> und Option<T>: Fehlerbehandlung als Typ statt Exceptions. Inspiriert von Rust, zunehmend in TypeScript-Projekten.
- Exhaustive Switch und Assertion Functions: vergessene Union-Fälle sind Compile-Time-Fehler. Assertion Functions für Runtime-Validierung mit Typ-Narrowing.
- Overloads vs. Conditional Return Types: wann welcher Ansatz für Funktionen mit verschiedenen Rückgabetypen.
- Praxis-Übung: Result-Monad implementieren: Result<T, E> mit map(), flatMap(), unwrapOr(). API-Service, der Result statt throw nutzt - Fehlerbehandlung ist im Typsystem erzwungen.
- Monorepo-Struktur: Shared Types zwischen Frontend und Backend (ein Type-Package, von beiden importiert). Turborepo oder Nx für Build-Orchestrierung. Package-interne Typen vs. exportierte API-Typen.
- Barrel Files und Public API: index.ts als kontrollierter Export - interne Implementierung verstecken, nur die Public API typisieren. Re-Exports und Type-Only Exports (export type).
- Declaration Files (.d.ts): Typen für ungetypte JavaScript-Libraries schreiben. DefinitelyTyped (@types/*) verstehen und beitragen. Ambient Declarations für globale Variablen.
- Strikte tsconfig für Produktionsprojekte: empfohlene Einstellungen (strict, noUncheckedIndexedAccess, exactOptionalPropertyTypes, noPropertyAccessFromIndexSignature) und was jede bewirkt.
- Praxis-Übung: Monorepo-Projekt aufsetzen: Shared-Types-Package, API-Package (Node.js), UI-Package (React oder Angular). Einen Typ im Shared-Package ändern -> Compiler-Fehler in API und UI sofort sichtbar.
7. TypeScript und Runtime-Validierung
- Das Compile-Time/Runtime-Gap: TypeScript validiert nur zur Compile-Time - zur Runtime können beliebige Daten ankommen (API-Responses, User-Input, Environment Variables). Ohne Runtime-Validierung ist Typsicherheit eine Illusion an den System-Grenzen.
- Zod: Schema definieren -> TypeScript-Typ wird automatisch abgeleitet (z.infer) -> Runtime-Validierung inklusive. Schemas für Objekte, Arrays, Unions, Transforms, Refinements. Integration mit Formularen (React Hook Form + Zod) und APIs (tRPC + Zod).
- Alternativen: Valibot (leichtgewichtig, tree-shakable), ArkType (Typ-basierte Syntax), io-ts (funktional). Entscheidungshilfe.
- Environment Variables typisieren: Env-Schema mit Zod validieren -> typsicherer Zugriff auf process.env.
- Praxis-Übung: API-Boundary absichern: Zod-Schema für User-Input definieren, TypeScript-Typ ableiten, Validierung in API-Handler integrieren. Ungültige Daten senden -> Zod liefert strukturierte Fehlermeldung, TypeScript-Typ ist trotzdem korrekt.
- Typen testen: expect-type und tsd für Compile-Time-Tests (ist dieser Typ wirklich das, was ich erwarte?). Besonders wichtig für Utility Types und generische Funktionen.
- Vitest mit TypeScript: moderner Test-Runner mit nativem TypeScript-Support (kein separater Compile-Schritt). Type-safe Mocks, Test-Fixtures mit Generics.
- Testbare Architekturen: Dependency Injection ohne Framework (Constructor Injection, Factory Functions), Interface-basierte Abstraktionen (Repository-Interface -> InMemory für Tests, Database für Produktion).
- Praxis-Übung: Tests für die Result-Monad und das Validierungs-Framework aus Tag 1-2 schreiben. expect-type für Typ-Assertions. Vitest für Laufzeit-Tests. Mock-Repository mit Interface.
Phase 1 - Eigenes Projekt typisieren (40 Min):
- Eigenes Projekt oder vorgegebenes Szenario (Task-Management-API mit Frontend). Vollständiges Typsystem entwerfen: Domain-Modell mit Discriminated Unions, generische Repository- und Service-Schicht, API-DTOs als abgeleitete Utility Types, Zod-Schemas an den System-Grenzen, Result<T, E> für Fehlerbehandlung, Branded Types für IDs.
- Vorbereitetes TypeScript-Projekt mit absichtlichen Schwächen reviewen: any-Verwendung, fehlende Discriminated Unions (nullable statt Union), duplizierte Interfaces statt Utility Types, unsichere Type Assertions (as), fehlende Runtime-Validierung an API-Grenze. Schwächen identifizieren, refactoren, Verbesserung im Typsystem zeigen.
- Eigenes Typsystem vorstellen. Stresstest: „Ein neuer Task-Status wird hinzugefügt - wie viele Stellen müssen geändert werden?" „Ein API-Consumer sendet ungültige Daten - wo fängt euer System das ab?" „UserId und ProjectId sind beide string - kann man sie versehentlich vertauschen?"
Zielgruppe & Vorkenntnisse
- TypeScript-Anwender mit Grundkenntnissen: Die Typen annotieren und Interfaces schreiben können, aber bei Generics, Mapped Types und fortgeschrittenen Patterns unsicher sind.
- Angular-, React- oder Vue-Entwickler: Die TypeScript täglich nutzen, aber das Typsystem nicht ausschöpfen - und Framework-APIs wie generische Hooks oder typisierte Event-Handler besser verstehen wollen.
- Umsteiger von TypeScript 3.x/4.x: Die die neuen 5.x-Features (Stage-3-Decorators, const Type Parameters, satisfies Operator) noch nicht produktiv einsetzen.
- Entwickler, die Code-Reviews für TypeScript-Projekte durchführen: Die fortgeschrittene Typisierungsmuster erkennen, bewerten und verbessern können müssen.
Ihre Schulung
In Präsenz | Online |
|---|---|
| Lernmethode | |
Ausgewogene Mischung aus Theorie und praktischen Übungen auf persönlichem Schulungs-PC. | Wie auch bei unseren Präsenz-Seminaren: Ausgewogene Mischung aus Theorie und praktischen Übungen. Trainer durchgehend präsent. |
| Unterlagen | |
Seminarunterlagen oder Fachbuch inklusive. Das Fachbuch wählt der Trainer passend zum Seminar aus - Ihren individuellen Buch-Wunsch berücksichtigen wir auf Nachfrage gerne. | Seminarunterlagen oder Fachbuch inklusive (via DHL). Das Fachbuch wählt der Trainer passend zum Seminar aus - Ihren individuellen Buch-Wunsch berücksichtigen wir auf Nachfrage gerne. |
| Arbeitsmaterialien | |
Din A4 Block, Notizblock, Kugelschreiber, USB-Stick, Textmarker, Post-its | |
| Teilnahmezertifikat | |
Nach Abschluss des Seminars erhalten Sie das Teilnahmezertifikat inkl. Inhaltsverzeichnis per E-Mail als PDF. | |
Organisation
In Präsenz | Online | |
|---|---|---|
| Teilnehmendenzahl | ||
min. 1, max. 8 Personen | ||
| Garantierte Durchführung * | ||
Ab 1 Teilnehmenden | ||
| Schulungszeiten | ||
| ||
| Ort der Schulung | ||
 GFU SchulungszentrumAm Grauen Stein 27 51105 Köln-Deutz oder online im Virtual Classroom oder europaweit bei Ihnen als Inhouse-Schulung Um ein optimales Raumklima zu gewährleisten, haben wir das Schulungszentrum mit 17 hochmodernen Trotec TAC V+ Luftreinigern ausgestattet. Diese innovative Filtertechnologie (H14 zertifiziert nach DIN EN1822) sorgt dafür, dass die Raumluft mehrfach pro Stunde umgewälzt wird und Schadstoffe zu 99.995% im HEPA-Filter abgeschieden und infektiöse Aerosole abgetötet werden. Zusätzlich sind alle Räume mit CO2-Ampeln ausgestattet, um jederzeit eine hervorragende Luftqualität sicherzustellen. | ||
| Räumlichkeiten | ||
Helle und modern ausgestattete Räume mit perfekter Infrastruktur | Bequem aus dem Homeoffice von überall | |
| All-Inclusive | ||
Frühstück, Snacks und Getränke ganztägig, Mittagessen im eigenen Restaurant, täglich 6 Menüs, auch vegetarisch | Eine Auswahl unserer Frühstücks-Snacks und Nervennahrungs-Highlights senden wir Ihnen mit den Seminarunterlagen via DHL zu. | |
| Barrierefreiheit | ||
Das GFU-Schulungszentrum (Am Grauen Stein 27) ist barrierefrei | - | |
Kostenfreie Services
In Präsenz | Online |
|---|---|
|
|
Buchungsmöglichkeiten
Online oder in Präsenz teilnehmen
Sie können sowohl Online als auch in Präsenz am Seminar teilnehmen. Klicken Sie bei Ihrer Buchung oder Anfrage einfach die entsprechende Option an.
- Lernumgebung in der Cloud
- Inhalte werden auf Wunsch an die Anforderungen Ihres Teams angepasst.
- Lernumgebung in der Cloud
- 1 Teilnehmender = Fokus aufs Fachliche und maximaler Raum für individuelle Fragen.
Was bedeutet Offene Schulung und Inhouse Schulung?
Bei einer offenen Schulung stehen Ort und Termin vorab fest. Jeder Interessent kann eine offene Schulung buchen, daher treffen Teilnehmer aus verschiedenen Unternehmen aufeinander.
Inhouse Schulungen können auf Ihren individuellen Schulungsbedarf zugeschnitten werden. Sie bestimmen den Teilnehmerkreis, Termin und Schulungsort.
Ist eine Inhouse Schulung die richtige Wahl?
Bei einer Inhouse Schulung gehen wir auf die individuellen Bedürfnisse Ihres Unternehmens ein und decken den Schulungsbedarf direkt bei Ihnen im Unternehmen ab.
Das spart Zeit und Geld und sorgt für einen schnellen Wissenstransfer Ihrer Mitarbeiter.
Wer kümmert sich um die Technik bei Inhouse Schulungen?
Eine komplette Lernumgebung in der Cloud mit Remote Zugriff ist für uns selbstverständlich. Sie müssen sich um nichts kümmern. Lediglich ein funktionierender PC oder Notebook mit Internetanschluss sollte für jeden Teilnehmer am Schulungstag bereit stehen.
Vorteile einer Inhouse Schulung
- Kompetente Seminarberatung
- Dozenten aus der Praxis
- Auf Ihre Bedürfnisse zugeschnittener individueller Lernstoff
- Sie können den Termin flexibel gestalten, so wie es für Sie am besten passt
- Unsere Inhouse Schulungen können Europaweit durchgeführt werden
- Der Fokus liegt auf Ihrem Schulungsbedarf, somit schonen Sie Ihr Budget
- Wissenslücken Ihrer Mitarbeitet werden schnell geschlossen