TypeScript-Dokumentation
Kompakte, beispielorientierte TypeScript-Referenz. Konzept lesen, Code ansehen, dann in einem Coddy-Lernweg üben.
Geführten TypeScript-Lernweg startenErste Schritte
- Was ist TypeScriptWas ist TypeScript? JavaScript mit statischen Typen. Du versiehst Werte mit Typen, der Compiler prüft sie, bevor der Code läuft, und heraus kommt normales JavaScript, das in jedem Browser und in Node.js, Deno und Bun läuft. Ein TypeScript Tutorial für den Einstieg.
- TypeScript vs JavaScriptTypeScript ist JavaScript plus ein statisches Typsystem, das geprüft wird, bevor der Code läuft. Der Unterschied im direkten Vergleich: Syntax, was die Typprüfung findet, der Build-Schritt, Geschwindigkeit, Lernkurve und wie du ein JavaScript-Projekt migrierst.
- TypeScript installierenTypeScript mit npm als Dev-Dependency im Projekt installieren, die Version mit npx tsc --version prüfen, mit tsc --init eine tsconfig.json anlegen und die erste Datei kompilieren. Mit globaler Installation, pnpm, Yarn und Bun sowie den typischen Fehlern.
- TypeScript ausführenFünf Wege, eine .ts-Datei auszuführen: mit tsc kompilieren und das JavaScript starten, direkt mit node file.ts (Type Stripping), mit tsx oder ts-node, oder mit Deno und Bun. Welche davon Typen prüfen, welche Syntax jeder unterstützt und welchen du wählen solltest.
- tsconfig.jsontsconfig.json markiert einen Ordner als TypeScript-Projekt und legt die Compiler-Optionen fest. Die wichtigen Optionen (target, module, moduleResolution, strict, rootDir, outDir, include, lib, types, noEmit, skipLibCheck), eine empfohlene Startkonfiguration, extends und was sich mit TypeScript 7 geändert hat.
- TypeScript 7TypeScript 7 ist der TypeScript-Compiler, neu geschrieben in Go als natives Programm: etwa zehnmal schneller, mit demselben tsc-Befehl und derselben Sprache. Was sich für Nutzer geändert hat (neue Standardwerte, entfernte Optionen, die fehlende JavaScript-API), welche Tools noch TypeScript 6 brauchen und wie das Upgrade gelingt.
- KommentareTypeScript verwendet die Kommentare von JavaScript mit // und /* */ sowie JSDoc-Kommentare mit /** */, die Editoren beim Hovern anzeigen. Außerdem liest es einige besondere Kommentare: @ts-expect-error, @ts-ignore, @ts-nocheck, @ts-check und /// <reference>-Direktiven.
- TypeScript vs PythonTypeScript und Python sind beide Hochsprachen mit Garbage Collection, aber TypeScript prüft seine Typen, bevor der Code läuft, während die Type Hints von Python optional sind und zur Laufzeit ignoriert werden. Ein direkter Vergleich von Typisierung, Laufzeit, Geschwindigkeit, Ökosystemen und Einsatzgebieten, mit demselben Programm in beiden Sprachen.
Grundlegende Typen
- GrundtypenDie eingebauten Typen von TypeScript: string, number, boolean, bigint, symbol, null und undefined, dazu Arrays und Objekte im Überblick. Wie man eine Typannotation schreibt, warum es keinen Integer-Typ gibt und warum man string statt String schreibt.
- TypinferenzTypeScript ermittelt die meisten Typen aus den Werten, die du schreibst. Was es für Variablen, let und const, Objekte, Arrays und Rückgabewerte ableitet, wie Callbacks ihre Typen aus dem Kontext bekommen und wo du trotzdem eine Annotation brauchst.
- StringsMit Strings in TypeScript arbeiten: Interpolation mit Template-Literalen, mehrzeilige Strings, prüfen, ob ein String einen Teilstring enthält, die gängigen Methoden und ihre Rückgabetypen sowie String-Literaltypen.
- String in ZahlEinen String in TypeScript mit Number(), parseInt(), parseFloat() oder unärem + in eine Zahl umwandeln, sehen, wie jede Variante mit Eingaben wie "42px", "" und "1e3" umgeht, NaN sicher prüfen und Zahlen wieder in Strings umwandeln.
- ArraysArrays in TypeScript typisieren: T[] vs Array<T>, Arrays von Objekten, Arrays mit mehreren Typen, readonly Arrays und was map, filter, reduce und find zurückgeben. Dazu die includes-Falle bei Literal-Arrays.
- TupelEin TypeScript-Tupel ist ein Array mit fester Anzahl von Elementen, deren Typen je Position bekannt sind, etwa [string, number]. Syntax, benannte, optionale und Rest-Elemente, readonly Tupel und as const, Tupel als Rückgabewert und der Unterschied zu Arrays.
- ObjekttypenObjekte in TypeScript typisieren: Inline-Objekttypen, optionale Eigenschaften mit ?, readonly Eigenschaften, verschachtelte Objekte, Methoden, Excess Property Checks und der Unterschied zwischen object, {} und Object.
- EnumsEin TypeScript-Enum ist eine benannte Menge von Konstanten, etwa enum Direction { Up, Down }. Numerische und String-Enums, das JavaScript, in das ein Enum kompiliert wird, Reverse Mapping, über ein Enum iterieren, const Enums und wann eine Union aus String-Literalen oder ein as const Objekt die bessere Wahl ist.
Spezielle Typen
- LiteraltypenEin Literaltyp ist ein Typ mit genau einem Wert, etwa "GET" oder 404. String-, Zahl- und Boolean-Literaltypen, Unions aus Literalen, warum let erweitert und const nicht, was as const bewirkt und const-Typparameter.
- any vs unknownany und unknown akzeptieren beide jeden Wert. any schaltet die Typprüfung für diesen Wert ab, während unknown dich zwingt, den Wert vor der Verwendung zu prüfen. Die Unterschiede, wie du unknown einengst, noImplicitAny und wo sich any in typisierten Code schleicht.
- never-Typnever ist der Typ ohne Werte. Er ist der Rückgabetyp von Funktionen, die nie fertig werden, der Typ, der übrig bleibt, wenn Narrowing jeden Fall ausgeschlossen hat, und das Werkzeug hinter vollständigen switch-Prüfungen. Woher er kommt und wie er sich von void unterscheidet.
- null und undefinedMit strictNullChecks sind null und undefined eigene Typen, die du in TypeScript behandeln musst. Wie du auf sie prüfst, Optional Chaining (?.), das doppelte Fragezeichen (??) und ??=, und der Unterschied zwischen einer optionalen Eigenschaft und | undefined.
- Non-Null-Assertion (!)Ein Ausrufezeichen hinter einem Wert, etwa user!, ist der Non-Null-Assertion-Operator: Er entfernt null und undefined aus dem Typ, ohne zur Laufzeit etwas zu prüfen. Was x! bewirkt, die Formen der Definite Assignment let x!: T und prop!: T, warum sie riskant sind und sicherere Alternativen.
Interfaces und Typaliase
- InterfacesEin Interface benennt die Form eines Objekts: welche Eigenschaften es hat und welche Typen sie enthalten. Wie du eines deklarierst, optionale und readonly Eigenschaften, Methoden, Index-Signaturen, Erweitern, Implementieren in einer Klasse, Declaration Merging, generische Interfaces und wie du einem Interface Standardwerte gibst.
- TypaliasseEin Typalias gibt jedem Typ mit dem Schlüsselwort type einen Namen: Objektformen, Unions, Tupeln, Funktionen, Generics und rekursiven Typen. Die Syntax, wie jede Form aussieht und warum ein Alias nur ein Name ist und kein neuer, eigenständiger Typ.
- interface vs typeinterface und type können beide Objektformen beschreiben, und meistens funktioniert beides. Die echten Unterschiede: Declaration Merging, Unions und Mapped Types, extends vs Intersections, implizite Index-Signaturen, Fehlermeldungen und Compiler-Performance, dazu eine klare Regel für die Wahl.
- extends-SchlüsselwortDas Schlüsselwort extends baut einen Typ aus einem anderen. Wie du ein Interface erweiterst (einmal oder aus mehreren), einen Typalias mit & erweiterst, einen Eigenschaftstyp überschreibst, Eigenschaften mit Omit ersetzt und was extends in Klassen, Generic Constraints und Conditional Types bedeutet.
- Union-TypenEin Union-Typ wie string | number bedeutet, dass ein Wert einer von mehreren Typen sein kann. Was du mit einer Union tun kannst (nur das, was jeder Member unterstützt), wie du sie einengst, Unions aus Literalen und Objekttypen und der Unterschied zwischen (A | B)[] und A[] | B[].
- Intersection-TypenEin Intersection-Typ A & B beschreibt einen Wert, der zugleich A und B ist, also jeden Member beider hat. Wie du Objekttypen mit & kombinierst, warum widersprüchliche Eigenschaften zu never werden, wie Intersections von Unions nur die gemeinsamen Member behalten und wann stattdessen extends passt.
- Discriminated UnionsEine Discriminated Union ist eine Union aus Objekttypen, die eine gemeinsame Literal-Eigenschaft als Tag haben, etwa kind oder status. Die Prüfung des Tags engt das ganze Objekt ein. Das Muster, Narrowing mit switch, Vollständigkeitsprüfung mit never und wie du API-Ergebnisse, Request-Zustände und Zustandsautomaten modellierst.
Funktionen
- FunktionenFunktionen in TypeScript typisieren: jeden Parameter annotieren, den Rückgabetyp annotieren oder ableiten lassen, void für Funktionen ohne Rückgabewert verwenden und Arrow Functions, Funktionsausdrücke, async-Funktionen und den this-Parameter typisieren.
- FunktionstypenDen Typ einer Funktion in TypeScript schreiben: die Arrow-Syntax (a: number) => string, Typaliasse für Funktionen, Arrow Functions und Callbacks typisieren, Call und Construct Signatures und warum der Typ Function zu locker ist.
- Optionale ParameterEinen TypeScript-Parameter mit ? optional machen, ihm einen Standardwert geben oder mit einem Rest-Parameter beliebig viele Argumente sammeln. Mit den Regeln zur Reihenfolge, weggelassen vs undefined, Options-Objekten und optionalen Parametern in Funktionstypen.
- FunktionsüberladungMit Funktionsüberladungen in TypeScript hat eine Funktion mehrere Aufrufsignaturen, jede mit eigenem Rückgabetyp. Das Muster aus Overload Signatures und Implementierung, die Regeln, die der Compiler prüft, wann ein Union-Parameter besser ist und Überladungen in Klassen.
Narrowing und Typprüfung
- Type NarrowingNarrowing ist die Art, wie TypeScript einen weiten Typ wie string | number in einem if, einem switch oder nach einem frühen return zu einem konkreten Typ macht. Alle Formen des Narrowing an einem Ort: typeof, Truthiness, Gleichheit, in, instanceof, Zuweisungen, Type Predicates und Discriminated Unions.
- typeof-Operatortypeof hat in TypeScript zwei Aufgaben. Im Code ist es der JavaScript-Operator, der zur Laufzeit "string", "number", "object" und so weiter zurückgibt, und TypeScript engt anhand davon ein. In einem Typ ist es die Type Query, die den Typ einer Variablen kopiert, wie in keyof typeof obj und ReturnType<typeof fn>.
- instanceof-Operatorinstanceof prüft zur Laufzeit, ob ein Objekt von einer Klasse erzeugt wurde, und TypeScript engt die Variable auf diese Klasse ein. Wie das mit eigenen Klassen und Error-Unterklassen funktioniert, warum es keine Interfaces oder Typaliasse prüfen kann und wo es überraschende Antworten gibt.
- Type GuardsEin Type Guard ist eine Prüfung zur Laufzeit, die TypeScript versteht. Die eingebauten Guards, wie du mit einem Predicate value is Type eigene schreibst, wie du prüfst, ob ein Objekt einen Typ hat, Assertion-Funktionen mit asserts und wie du unbekannte Daten validierst.
- Typ-AssertionsDas Schlüsselwort as sagt TypeScript, einen Wert als anderen Typ zu behandeln. Es ist kein Cast: Zur Laufzeit wird nichts umgewandelt oder geprüft. Die Syntax mit as und spitzen Klammern, was der Compiler erlaubt, doppelte Assertions über unknown und wann ein Type Guard das bessere Werkzeug ist.
- satisfies-OperatorDer Operator satisfies prüft, ob ein Wert zu einem Typ passt, ohne den abgeleiteten Typ des Werts zu ändern. Was er tut, wie er sich zu einer Typannotation und zu as verhält (dasselbe Objekt auf drei Arten geschrieben), wie er sich mit as const kombinieren lässt und warum er zu Konfigurationsobjekten passt.
Klassen
- KlassenTypeScript-Klassen sind JavaScript-Klassen mit typisierten Feldern, Methoden und Konstruktoren. Wie Felddeklarationen und strictPropertyInitialization funktionieren, wie du this typisierst, Getter und Setter, statische Member, implements und wie eine Klasse zugleich ein Typ ist.
- KonstruktorenDen Konstruktor einer Klasse in TypeScript typisieren: typisierte und optionale Parameter, Parameter Properties wie constructor(private name: string), Reihenfolge der Feldinitialisierung, Konstruktor-Überladungen, super-Aufrufe in Unterklassen, private Konstruktoren und Konstruktortypen mit new.
- ZugriffsmodifikatorenTypeScript hat drei Zugriffsmodifikatoren, public, private und protected, dazu readonly. Was jeder erlaubt, warum private in TypeScript eine Prüfung beim Kompilieren ist, während #private-Felder in JavaScript zur Laufzeit durchgesetzt werden, und was du wählen solltest.
- VererbungKlassenvererbung in TypeScript: extends und super, Methoden mit kompatiblen Typen überschreiben, das Schlüsselwort override und noImplicitOverride, protected Member, Felder mit declare neu deklarieren und wann implements das bessere Werkzeug ist.
- Abstrakte KlassenEine abstrakte Klasse in TypeScript ist eine Basisklasse, die nicht instanziiert werden kann und Methoden den Unterklassen zur Implementierung überlassen kann. Abstrakte Methoden und Eigenschaften, das Template-Method-Muster, abstrakte Konstruktortypen und wann ein Interface die bessere Wahl ist.
- DecoratorsDecorators sind Funktionen, die Klassenmember mit der @-Syntax umhüllen oder ersetzen. Die Standard-Decorators, die TypeScript ohne Flag unterstützt (Klasse, Methode, Getter, Feld und Accessor), Decorator Factories, addInitializer und der Unterschied zu den älteren experimentalDecorators von Angular und NestJS.
Generics
- GenericsMit Generics arbeitet eine Funktion, ein Interface, ein Typ oder eine Klasse mit vielen Typen und hält sie dabei verbunden: Was hineingeht, bestimmt, was herauskommt. Generische Funktionen, Inferenz von Typargumenten, mehrere Typparameter, generische Interfaces und Klassen, Standardwerte und wann man Generics besser lässt.
- Generic ConstraintsEin Generic Constraint, T extends Something, begrenzt, welche Typen ein Typparameter akzeptiert, und erlaubt der Funktion, das zu nutzen, was der Constraint garantiert. Mit extends für Objektformen und Interfaces, K extends keyof T für sicheren Eigenschaftszugriff, Constraints auf primitive Typen und den Fehlern, denen du begegnen wirst.
Typoperatoren
- keyof-Operatorkeyof nimmt einen Objekttyp und liefert die Union seiner Eigenschaftsnamen. keyof mit Interfaces, keyof typeof für einfache Objekte, typisierter Eigenschaftszugriff mit Generics, Index-Signaturen (string | number) und warum Object.keys ein string[] zurückgibt.
- Indexed Access TypesEin Indexed Access Type liest den Typ einer Eigenschaft aus einem anderen Typ: Person["age"] ist number. T["key"], Union-Schlüssel, T[keyof T], T[number] für Array-Elemente, Tupel-Indizes und (typeof arr)[number], um ein const-Array in eine Union zu verwandeln.
- Mapped TypesEin Mapped Type baut einen neuen Objekttyp, indem er über Schlüssel iteriert: { [K in keyof T]: ... }. Die Syntax, die Modifikatoren readonly und ? mit + und -, Key Remapping mit as, das Filtern von Schlüsseln und wie Partial, Readonly, Required, Pick und Record geschrieben sind.
- Conditional TypesEin Conditional Type wählt anhand eines Tests einen von zwei Typen: T extends U ? X : Y. Die Syntax, wie Conditional Types sich über Unions verteilen (und wie du das abstellst), Typen mit infer herausziehen und wie du ReturnType selbst schreibst.
- Template Literal TypesTemplate Literal Types bauen String-Literaltypen mit derselben Backtick-Syntax wie Template Strings in JavaScript: `on${Capitalize<E>}`. Die Syntax, wie sich Unions multiplizieren, Uppercase und Capitalize, Muster wie `${number}px`, Getter mit Mapped Types und Strings mit infer zerlegen.
- Branded TypesEin Branded Type ist ein primitiver Typ mit einer unsichtbaren Markierung, etwa string & { readonly __brand: "UserId" }, sodass sich eine UserId nicht dort übergeben lässt, wo eine OrderId erwartet wird. Wie Brands funktionieren, validierende Konstruktorfunktionen, ein generischer Brand-Helfer, Brands mit unique symbol und gebrandete Zahlen.
Utility Types
- Utility TypesJeder eingebaute Utility Type von TypeScript an einem Ort: Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, Parameters, ReturnType, Awaited, die String-Typen und mehr, jeweils mit einer Beschreibung in einem Satz und einem ausführbaren Beispiel.
- RecordRecord<K, V> ist der Objekttyp, dessen Schlüssel K und dessen Werte alle V sind. Record mit String-Schlüsseln und mit Union-Schlüsseln (jeder Schlüssel verpflichtend), Partial<Record>, über einen Record mit typisierten Schlüsseln iterieren, die Falle mit fehlenden Schlüsseln und wann eine Index-Signatur oder eine Map besser passt.
- Partial und RequiredPartial<T> macht jede Eigenschaft von T optional, und genau das ist der Typ eines Update- oder Patch-Objekts. Partial in Update-Funktionen, warum es nur eine Ebene tief wirkt, wie du ein DeepPartial schreibst, die Falle mit explizitem undefined und das Gegenstück Required<T>.
- OmitOmit<T, K> erzeugt einen Typ mit allen Eigenschaften von T außer den Schlüsseln K. Omit mit einem und mehreren Schlüsseln, einen Eigenschaftstyp überschreiben, die Eigenschaft zur Laufzeit entfernen, Omit vs Exclude und Pick, warum Omit Schlüssel akzeptiert, die es nicht gibt, ein striktes Omit und Omit auf Union-Typen.
- PickPick<T, K> erzeugt einen Typ, der nur die Eigenschaften von T enthält, deren Schlüssel in K stehen. Pick mit einem oder mehreren Schlüsseln, wie es Schlüssel prüft, Pick vs Omit, Auswahl aus verschachtelten Typen, eine typisierte pick()-Funktion und Eigenschaften nach ihrem Werttyp auswählen.
- readonly und ReadonlyDer Modifikator readonly und der Utility Type Readonly<T> verhindern, dass Code Eigenschaften neu zuweist. readonly-Eigenschaften und Klassenfelder, Readonly<T>, readonly-Arrays (readonly T[] und ReadonlyArray), ReadonlyMap und ReadonlySet, warum readonly flach ist und nur beim Kompilieren gilt und wie es sich zu Object.freeze und as const verhält.
- Exclude und ExtractExclude, Extract und NonNullable filtern die Member eines Union-Typs. Was jeder behält und entfernt, wie du Union-Member nach ihrer Form auswählst, wie sie aus Conditional Types gebaut sind und wie sie sich von Omit und Pick unterscheiden.
- ReturnType und ParametersReturnType, Parameters, ConstructorParameters, InstanceType und Awaited holen Typen aus Funktionen, Klassen und Promises. Wie du sie mit typeof verwendest, wie du den Ergebnistyp einer async-Funktion bekommst, was bei Überladungen und Generics passiert und wie ReturnType mit infer gebaut ist.
Schleifen und Collections
- SchleifenAlle Schleifenarten in TypeScript und welche Typen sie liefern: die klassische for-Schleife, for...of über Arrays, Maps und Strings, for...in und seine String-Schlüssel, forEach (kein break, kein await), typisierte Schleifen über Objektschlüssel und while.
- switch-AnweisungDie switch-Anweisung in TypeScript: Syntax, wie jeder case einen Union-Typ einengt, vollständige switches, die nicht kompilieren, wenn ein Fall fehlt, das Muster switch (true), Fallthrough und Block-Scope.
- MapMap in TypeScript verwenden: eine typisierte Map<K, V> erzeugen, warum get V | undefined zurückgibt, set, has und delete, Iteration in Einfügereihenfolge, Objekte als Schlüssel, Umwandlung in und aus Objekten und JSON, Map vs Objekt vs Record und array.map() typisieren.
- DictionaryTypeScript hat keine Dictionary- oder Hashmap-Klasse; ein Lookup mit Schlüsseln und Werten typisierst du mit einer Index-Signatur, Record<K, V> oder Map<K, V>. Jede Variante erklärt, wie du prüfst, ob ein Schlüssel existiert, hinzufügst, löschst und iterierst, und warum noUncheckedIndexedAccess für Dictionaries wichtig ist.
Asynchronität und Fehler
- PromisesWie Promises in TypeScript typisiert werden: der Typ Promise<T>, new Promise und resolve typisieren, wie then den Typ ändert, warum catch dir any gibt, Promise.all mit Tupel-Ergebnissen, die Ergebnistypen von Promise.allSettled und Callback-APIs in ein typisiertes Promise verpacken.
- Async/AwaitWie async und await in TypeScript typisiert werden: Eine async-Funktion gibt Promise<T> zurück, await packt es aus, Fehler fängt man mit try/catch, Top-Level await braucht ein ES-Modul, und der Unterschied zwischen einzelnem Warten, parallelem Warten und der forEach-Falle.
- FehlerbehandlungFehlerbehandlung in TypeScript: warum die catch-Variable unknown ist, wie du sie mit instanceof Error einengst, Fehler werfen, eigene Fehlerklassen mit name und cause schreiben und das Result-Muster für erwartete Fehler.
- SleepTypeScript hat kein eingebautes sleep, aber eine Zeile liefert dir eines: eine Funktion, die ein Promise<void> zurückgibt, das setTimeout auflöst. Wie du darauf mit await wartest, in Schleifen pausierst, mit Verzögerung erneut versuchst, ein sleep abbrichst und warum es in JavaScript kein blockierendes sleep gibt.
Module und Tooling
- ModuleJede TypeScript-Datei mit einem import oder export auf oberster Ebene ist ein Modul. Benannte und Default-Exports, import type und export type, wie die Einstellung module zwischen ES-Modul und CommonJS-Ausgabe entscheidet und warum node16 und nodenext .js-Endungen in Imports verlangen.
- NamespacesEin TypeScript-Namespace fasst Werte und Typen unter einem Namen zusammen und wird zu einem einfachen Objekt kompiliert. Syntax, wie Namespaces miteinander und mit Funktionen und Klassen verschmelzen, warum ES-Module sie abgelöst haben und wo sie dir noch begegnen: in Deklarationsdateien und bei globaler Augmentation.
- DeklarationsdateienEine .d.ts-Datei beschreibt die Typen von JavaScript-Code, ohne selbst Code zu enthalten, und das Schlüsselwort declare tut dasselbe in einer .ts-Datei. Wie Deklarationsdateien erzeugt werden, welche Rolle @types-Pakete spielen, wie du ein untypisiertes Modul typisierst und wie declare global und Module Augmentation bestehende Typen erweitern.
- Strict Modestrict: true in tsconfig.json schaltet eine Familie von Typprüfungen ein: noImplicitAny, strictNullChecks, strictPropertyInitialization und fünf weitere. Was jede davon findet, wie du den Strict Mode in einem bestehenden Projekt aktivierst und welche nützlichen Flags strict nicht enthält.
- JSONJSON.parse gibt any zurück, also vertraut TypeScript jedem Typ, den du dem Ergebnis gibst. Wie du geparstes JSON typisierst, mit einem Type Guard validierst, aus einem JSON-Beispiel ein Interface machst, .json-Dateien importierst und was JSON.stringify mit Dates, Sets und undefined macht.
Weiterführend
- Best PracticesAcht TypeScript-Gewohnheiten, die echte Bugs verhindern: strict anlassen, unknown statt any, Inferenz arbeiten lassen, Unions statt Enums, Konfiguration mit satisfies prüfen, Zustand mit Discriminated Unions modellieren, ! und as vermeiden und Daten readonly machen. Jede mit einem ausführbaren Vorher und Nachher.
- Interviewfragen25 TypeScript-Interviewfragen mit kurzen, korrekten Antworten und Code, von Einsteiger bis Fortgeschritten gruppiert: any vs unknown, interface vs type, Generics, Narrowing, Utility Types, Mapped und Conditional Types, strukturelle Typisierung, tsconfig und TypeScript 7.
