# TypeScript

## Was es ist

TypeScript ist eine Programmiersprache von Microsoft, die JavaScript um Typannotationen
und einen Compiler namens `tsc` ergänzt, der sie prüft. Der Name wird zu TS abgekürzt;
die Dateien enden auf `.ts` oder, wenn sie JSX-Markup enthalten, auf `.tsx`.
JavaScript-Syntax ist gültiges TypeScript, weshalb die Sprache als Obermenge von
JavaScript bezeichnet wird. Der Compiler ist quelloffen und steht unter der Apache
License 2.0.

Die Typen bestehen nur für die Dauer der Prüfung. Gewöhnliche Typannotationen werden
entfernt, wenn TypeScript JavaScript ausgibt; sie validieren nichts zur Laufzeit und
erfordern keine Laufzeitbibliothek zur Typprüfung. Typannotationen ändern nicht, wie
sich der JavaScript-Code bei der Ausführung verhält. Dieser eine Umstand erklärt
Nutzen und Grenzen zugleich: Die Typprüfung beurteilt die im Quelltext beschriebenen
Typen; Daten, die während der Ausführung eintreffen, validiert sie nicht.

Das Typsystem ist strukturell. Zwei Typen sind kompatibel, wenn ihre Strukturen
zusammenpassen, unabhängig von ihren Namen. Das passt zu JavaScripts üblicher Praxis,
einfache Objekte weiterzugeben; C# und Java vergleichen dagegen deklarierte Namen. Viele
Typen werden abgeleitet, weshalb Annotationen vor allem an Funktionssignaturen und
exportierten Werten stehen. An einigen Stellen ist das System zudem bewusst nicht
typsicher. `any` schaltet die Prüfung für einen Wert ab, und eine Typzusicherung mit
`as` weist den Compiler an, sich auf die Typangabe der programmierenden Person zu
verlassen. Beide verschwinden wie die übrigen Typangaben aus der Ausgabe.

Für die Ausführung gibt es drei gängige Wege. `tsc` prüft ein Projekt und gibt
JavaScript aus. Bundler wie esbuild entfernen die Typen ungeprüft und überlassen die
Prüfung einem gesonderten Lauf von `tsc --noEmit`. Node.js führt seit v23.6.0 und
v22.18.0 `.ts`-Dateien direkt aus, indem es die Typsyntax durch Leerraum ersetzt,
ebenfalls ohne Typprüfung, und akzeptiert nur Syntax, die sich so entfernen lässt.
TypeScript 7.0, angekündigt im Juli 2026, ist eine native Go-Version des Compilers,
die nach Angaben des Teams vollständige Builds typischerweise 8- bis 12-mal schneller
erledigt.

## Warum es wichtig ist

Ein Team muss entscheiden, ob sich ein Build-Schritt und eine Typprüfung lohnen, weil
sie Fehler vor der Ausführung finden. In einer Codebasis, die jede Woche von mehreren
Personen geändert wird, ist das meist der Fall. Beim Umbenennen eines Feldes werden
alle Verwendungsstellen sichtbar; der Editor vervollständigt und erklärt Code anhand
der Typen, und die Signatur eines Moduls wird zum Vertrag, den aufrufender Code nicht
unbemerkt verletzen kann. Dem stehen eine Prüfung bei jedem Build, eine
Konfigurationsdatei mit vielen Optionen und Typdefinitionen gegenüber, die mit den
beschriebenen Bibliotheken Schritt halten müssen.

Am wichtigsten ist die Einstellung der Strenge. Das Flag `strict` aktiviert eine
Gruppe von Prüfungen, darunter `strictNullChecks` und `noImplicitAny`; das Handbuch
beschreibt das Ergebnis eher als Drehregler denn als Schalter. Seit TypeScript 6.0 ist
das Flag standardmäßig aktiviert, sodass ein neues Projekt mit strengen Prüfungen beginnt. In einem älteren Projekt
kann es weiterhin auf false stehen; es später einzuschalten bedeutet, jede betroffene
Datei durchzuarbeiten. Zwei nützliche Prüfungen gehören nicht zu dieser Gruppe und
müssen gesondert aktiviert werden: `noUncheckedIndexedAccess` und
`exactOptionalPropertyTypes`.

Das Entfernen der Typen setzt die Grenze. Liest ein Programm JSON aus einer
Netzwerkanfrage, einer Datei, einer Warteschlange oder einem Formular, beruht die
angenommene Datenstruktur allein auf der Aussage der programmierenden Person, denn
beim Eintreffen der Daten sind die Typen bereits weg. An den Grenzen ist deshalb eine
Validierung zur Laufzeit nötig, idealerweise aus derselben Definition erzeugt wie die
Typen, damit Prüfung und Typ nicht voneinander abweichen können. TypeScript sorgt im
Inneren eines Programms für Konsistenz und überlässt die Ränder dem Code.

Die Typprüfung versorgt auch andere Werkzeuge. Ein Linter wie typescript-eslint kann
Typinformationen beim Compiler abfragen, sodass eine Regel ein Promise meldet, auf
das niemand wartet, oder einen Wert vom Typ `any`, der sich durch ein Modul zieht.
So führt ein Verstoß gegen die eigenen Konventionen zu einer Fehlermeldung statt zu
einem Review-Kommentar.

## Wie es in der Praxis aussieht

In den auf dieser Website gezeigten Projekten wird die Verlässlichkeit von TypeScript
durch generierten Code und Werkzeuge gesichert, statt durch Konventionen. Drei Seiten
zeigen, wie das geschieht.

Auf einer Plattform wird der TypeScript-Client des Frontends nie von Hand geschrieben.
[Er wird aus der Beschreibung der API selbst erzeugt](/de/portfolio/generated-the-api-contract-from-the-database-out/),
die Huma aus den Go-Typen ausgibt; diese folgen wiederum dem Datenbankschema und seinen
Funktionen. Zum dokumentierten Implementierungsstand umfasste der Client 44.076
Zeilen. 61 gleichzeitig generierte Mock-Handler ließen die Frontend-Tests gegen den
tatsächlichen Vertrag laufen statt gegen eine handgeschriebene Fixture. Jeder
Übergang hat seine eigene Prüfung. Eine Vertragsprüfung in CI vergleicht, was das
Frontend sendet, mit dem, was die API erwartet, und lässt den Build bei Abweichungen
fehlschlagen. Darunter untersucht eine Schemaprüfung die tatsächlichen Strukturen.
Erfasst werden optionale Body-Felder, bei denen fehlend und null leicht verwechselt
werden, und Enums in Abfrageparametern. Ändert sich ein Feld nur auf einer Seite,
scheitert nun wenige Minuten nach der Änderung ein Build, statt dass nach der
Auslieferung der Abweichung ein 422 im Browser erscheint. Im Gegenzug erreicht eine
Vertragsänderung die Typen des Clients nur, wenn die Kette erneut durchlaufen wird,
und die erneute Generierung ist lästig.

Eine weitere Seite legt für sechs Sprachen, darunter TypeScript, denselben Maßstab
an. [Jede von ESLint gemeldete Diagnose ist ein Fehler](/de/portfolio/set-a-zero-warnings-bar-across-six-languages/).
Es gibt keine Warnstufe, in der sich etwas verstecken ließe, und Inline-Unterdrückungen
sind verboten: Ein Befund muss behoben statt stummgeschaltet werden. Pre-Commit- und
Pre-Push-Hooks führen Linter und Tests aus; Längengrenzen für Funktionen und Dateien
halten Module lesbar.

Die mit einer Sprache gelieferten Linter reichen nicht bis zu den projektspezifischen
Regeln. Deshalb sicherten zum dokumentierten Implementierungsstand
[fünfzehn eigene ESLint-Regeln](/de/portfolio/built-a-268-check-guard-engine-for-the-repo/)
die TypeScript-Muster dieses Repositorys. Sie gehörten zu einem Prüfsystem mit 274
Prüfskripten, von denen 268 in den Commit-Hooks registriert waren. Die Prüfungen
hatten selbst 146 Tests, denn eine defekte Prüfung lässt alles unbemerkt durch. Eine
Regel betrifft Tests statt Typen: Ein Commit mit dem Präfix `fix:` muss einen Test
enthalten, der ohne die Korrektur fehlschlägt. Die Review-Zeit verlagerte sich von
formalen Fragen auf Entwurfsentscheidungen; im Gegenzug wurde das Committen langsam.

## Wo es schiefgeht

Die meisten TypeScript-Fehler entstehen, wenn den Typen über das hinaus vertraut wird,
was der Compiler sehen kann.

**Ein als String typisiertes Feld ist zur Laufzeit undefined.** Die Daten kamen von
außerhalb des Programms und erhielten einen Typ, statt geprüft zu werden. Die
DOM-Bibliothek typisiert `res.json()` als Promise von `any`; deshalb akzeptiert der
Compiler alles, was der Code mit dem Ergebnis anstellt. Eine Typzusicherung macht das
Vertrauen ausdrücklich, aber nicht sicher:

```ts
const res = await fetch("/api/user");
const user = (await res.json()) as User; // trusted, never checked
user.email.toLowerCase(); // TypeError if email is missing
```

Externe Daten sollten als `unknown` behandelt und an der Systemgrenze zur Laufzeit
anhand eines Schemas validiert werden. Der Typ sollte aus diesem Schema erzeugt
werden, damit beide zusammenpassen.
Eine typgestützte Lint-Regel kann dann jedes `any` melden, das dennoch durchrutscht.

**Code mit Typfehlern erreicht trotzdem die Produktion.** `tsc` schreibt auch dann
JavaScript, wenn es Fehler meldet, weil `noEmitOnError` standardmäßig false ist.
Bundler und Node.js entfernen Typen, ohne sie überhaupt zu prüfen. `tsc --noEmit`
sollte als verpflichtender Schritt in CI und im Pre-Commit-Hook laufen; ein Fehler-Exitcode
muss den Build scheitern lassen.

**Ein Indexzugriff liefert undefined, das der Typ ausgeschlossen hatte.** Das Lesen
eines Array-Elements oder eines Schlüssels über eine Indexsignatur wird so typisiert,
als sei der Wert immer vorhanden, selbst jenseits des Array-Endes.
Wird `noUncheckedIndexedAccess` aktiviert, fügt es solchen Zugriffen `undefined` hinzu und zwingt den Code,
damit umzugehen. Ergänzend sollte `exactOptionalPropertyTypes` aktiviert werden; es unterscheidet
eine fehlende Eigenschaft von einer auf `undefined` gesetzten.

**Eine mit tsc kompilierbare Datei scheitert bei der Ausführung durch Node.js.** Das
Entfernen der Typen beseitigt nur Syntax ohne Laufzeitbedeutung. Enums und Namespaces,
die Werte enthalten, lassen Node.js mit `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` abbrechen.
Ein ohne das Schlüsselwort `type` importierter Typ gilt als Wertimport und scheitert
zur Laufzeit. Mit `erasableSyntaxOnly` und `verbatimModuleSyntax` meldet der Compiler
beides vor Node.js. Für Typen sollte `import type` verwendet werden; Enums lassen sich
durch mit `as const` markierte Objektliterale ersetzen.

## Weiterführende Lektüre

- [TypeScript Documentation](https://www.typescriptlang.org/docs/) — Handbuch,
  Referenzseiten und Versionshinweise, gepflegt vom TypeScript-Team.
- [The Basics](https://www.typescriptlang.org/docs/handbook/2/basic-types.html) — das
  Handbuchkapitel über statische Prüfung, Ausgabe trotz Fehlern, entfernte Typen und
  Strenge.
- [TSConfig Reference: strict](https://www.typescriptlang.org/tsconfig/#strict) — jede
  Compileroption mit ihrem Standardwert, einschließlich der durch strict aktivierten
  Prüfungen.
- [Type Compatibility](https://www.typescriptlang.org/docs/handbook/type-compatibility.html)
  — strukturelle Subtypisierung und die Stellen, an denen das Typsystem bewusst nicht
  typsicher ist.
- [Node.js: Modules: TypeScript](https://nodejs.org/api/typescript.html) — das Entfernen
  von Typen, die dabei abgewiesene Syntax und die von Node.js empfohlenen
  Compilereinstellungen.
- [Linting with Type Information](https://typescript-eslint.io/getting-started/typed-linting/)
  — wie typescript-eslint Lint-Regeln Zugang zur Typprüfung gibt.

<https://engineer.company/de/glossary/typescript/>
