TypeScript: Der Weg zu weniger Fehlern und wartbarem JavaScript-Code

Typsystem, strict-Modus und schrittweise Migration: Was TypeScript gegen Laufzeitfehler leistet und wo seine Grenzen liegen
Aktualisiert:
Abstract
- #TypeScript
- #JavaScript
- #Programmierung
- #Webentwicklung
- #Frontend
- #Backend
- #Statische Typisierung
- #Compiler
- #Entwickler-Tools
- #IDE
- #Type Definitions
- #Typisierung
- #Codequalität
- #Fehlervermeidung
- #Migration
Statische Typen finden Fehler, bevor der Code läuft – aber nur so viele, wie Sie zulassen
Ein Webshop zeigt im Warenkorb plötzlich „NaN €“ an. Die Ursache ist schnell gefunden, nachdem ein Kunde sich beschwert hat: Eine Schnittstelle liefert den Preis seit dem letzten Update als Text statt als Zahl, und an einer Stelle wird aus "19.90" + 5 die Zeichenkette "19.905", an einer anderen aus undefined * 2 der Wert NaN. JavaScript beschwert sich über nichts davon. Es rechnet einfach weiter.
Genau für diese Art von Fehlern gibt es TypeScript. Die Sprache legt über JavaScript ein Typsystem, das solche Widersprüche schon im Editor meldet – bevor der Code überhaupt ausgeführt wird. Fehlerfrei wird Software dadurch nicht. Aber eine ganze Klasse von Fehlern, die in reinem JavaScript erst in Produktion auffällt, verschwindet weitgehend. Wie das funktioniert, wo die Grenzen liegen und wie Sie ein bestehendes Projekt umstellen, erklären die folgenden Abschnitte.
Was TypeScript ist – und was nicht
TypeScript ist eine Obermenge von JavaScript: Jedes gültige JavaScript-Programm ist im Prinzip auch gültiges TypeScript. Hinzu kommen Typangaben, also Hinweise darauf, welche Art von Wert eine Variable, ein Funktionsparameter oder ein Rückgabewert haben darf. Microsoft hat die Sprache 2012 veröffentlicht, sie ist quelloffen und wird bis heute von Microsoft gepflegt.
Wichtig für das Verständnis: Browser und Node.js führen kein TypeScript aus, sondern JavaScript. Die Typangaben dienen ausschließlich der Prüfung während der Entwicklung. Vor der Ausführung werden sie entfernt – entweder durch den TypeScript-Compiler tsc, durch ein Build-Werkzeug wie Vite, esbuild oder SWC oder inzwischen auch direkt durch die Laufzeitumgebung. Zur Laufzeit existieren die Typen nicht mehr.
Daraus folgt eine Einschränkung, die viele Einsteiger überrascht: TypeScript prüft nur, was es sehen kann. Daten, die zur Laufzeit von außen kommen – aus einer API, einem Formular oder einer Datenbank –, kennt der Compiler nicht. Behauptet der Code, die Antwort eines Servers habe ein bestimmtes Format, glaubt TypeScript das. Ob es stimmt, muss eine Validierung zur Laufzeit klären. Mehr dazu weiter unten.
Wie das Typsystem Fehler früh sichtbar macht
Typangaben und Typinferenz
Typen lassen sich ausdrücklich angeben oder von TypeScript ableiten. Diese Ableitung heißt Typinferenz: Der Compiler erkennt aus dem zugewiesenen Wert selbst, welchen Typ eine Variable hat.
let kundenname: string = 'Müller GmbH'; // ausdrücklich angegeben
let menge = 3; // abgeleitet: number
menge = 'drei';
// Fehler: Type 'string' is not assignable to type 'number'.
function bruttoPreis(netto: number, steuersatz: number): number {
return netto * (1 + steuersatz);
}
bruttoPreis('19.90', 0.19);
// Fehler: Argument of type 'string' is not assignable to parameter of type 'number'.
In der Praxis schreiben Sie Typen vor allem an Funktionsgrenzen, also bei Parametern und manchmal bei Rückgabewerten. Innerhalb von Funktionen genügt meist die Inferenz. Wer jede lokale Variable annotiert, macht den Code länger, aber nicht sicherer.
Objekte beschreiben: Interfaces und Typ-Aliase
Für Datenstrukturen gibt es Interfaces und Typ-Aliase. Beide beschreiben, welche Felder ein Objekt hat und welchen Typ diese Felder haben.
interface Bestellung {
id: string;
positionen: Position[];
gutscheincode?: string; // optional
}
interface Position {
artikelnummer: string;
menge: number;
einzelpreis: number;
}
function summe(bestellung: Bestellung): number {
return bestellung.positionen.reduce(
(gesamt, p) => gesamt + p.menge * p.einzelpreis,
0,
);
}
Der Nutzen zeigt sich nicht beim ersten Schreiben, sondern bei der nächsten Änderung. Benennt jemand im Team das Feld einzelpreis um, markiert der Editor sofort jede Stelle im Projekt, die noch den alten Namen verwendet. In reinem JavaScript fände man diese Stellen nur über eine Textsuche – oder gar nicht.
Union-Typen und Narrowing
Besonders hilfreich sind Union-Typen, also Typen, die mehrere Möglichkeiten zulassen. TypeScript verfolgt dann im Code, welche Möglichkeit an welcher Stelle noch infrage kommt. Dieses Eingrenzen heißt Narrowing.
type Zahlstatus =
| { status: 'offen' }
| { status: 'bezahlt'; bezahltAm: Date }
| { status: 'fehlgeschlagen'; grund: string };
function statusText(z: Zahlstatus): string {
switch (z.status) {
case 'offen':
return 'Zahlung ausstehend';
case 'bezahlt':
return `Bezahlt am ${z.bezahltAm.toLocaleDateString('de-DE')}`;
case 'fehlgeschlagen':
return `Fehler: ${z.grund}`;
}
}
Im Zweig 'bezahlt' weiß der Compiler, dass bezahltAm vorhanden ist. Kommt später ein vierter Status hinzu, meldet TypeScript, dass die Funktion nicht mehr für jeden Fall einen Rückgabewert liefert. Solche Hinweise sind es, die große Codebasen über Jahre wartbar halten.
Der strict-Modus: Wo die eigentliche Sicherheit herkommt
Wie streng TypeScript prüft, steuert die Datei tsconfig.json. Die wichtigste Einstellung darin ist strict; seit TypeScript 6.0 ist sie standardmäßig aktiv. Sie schaltet eine Gruppe von Prüfungen ein, ohne die TypeScript nur einen Teil seines Nutzens entfaltet. Die bekannteste davon ist strictNullChecks: Werte, die null oder undefined sein können, müssen vor der Verwendung geprüft werden.
interface Kunde {
name: string;
email?: string;
}
function domain(kunde: Kunde): string {
return kunde.email.split('@')[1];
// Fehler (strict): 'kunde.email' is possibly 'undefined'.
}
function domainSicher(kunde: Kunde): string | undefined {
return kunde.email?.split('@')[1];
}
Ohne strict würde der erste Code ohne Meldung kompiliert und zur Laufzeit mit „Cannot read properties of undefined“ abstürzen – einer der häufigsten JavaScript-Fehler überhaupt. Ebenfalls Teil von strict ist noImplicitAny. Es verhindert, dass Parameter ohne Typangabe stillschweigend den Typ any erhalten, mit dem jede Prüfung abgeschaltet ist.
Eine schlanke Konfiguration für ein neues Node.js-Projekt kann so aussehen:
{
"compilerOptions": {
"target": "ES2022",
"module": "NodeNext",
"strict": true,
"noUncheckedIndexedAccess": true,
"skipLibCheck": true,
"types": ["node"],
"rootDir": "src",
"outDir": "dist"
},
"include": ["src"]
}
noUncheckedIndexedAccess gehört nicht zu strict, lohnt sich aber: Ein Zugriff wie liste[5] liefert dann den Typ „Element oder undefined“, weil das Element ja fehlen kann. Welche Optionen es sonst gibt und wie sie zusammenspielen, beschreibt ausführlich der Beitrag TypeScript 5 Konfiguration.
Unsere Empfehlung: Neue Projekte starten immer mit strict: true. Die Strenge nachträglich einzuschalten ist deutlich mühsamer als sie von Anfang an zu haben.
Wo TypeScript nicht hilft
TypeScript wird gelegentlich als Garant für fehlerfreien Code verkauft. Das ist es nicht, und es lohnt sich, die Grenzen zu kennen.
- Logikfehler: Wenn eine Funktion den Rabatt falsch berechnet, aber eine Zahl zurückgibt, ist für TypeScript alles in Ordnung. Dafür braucht es weiterhin Tests.
- Daten von außen: Eine Typangabe für eine API-Antwort ist eine Behauptung, keine Prüfung. Bibliotheken wie Zod oder Valibot prüfen eingehende Daten zur Laufzeit gegen ein Schema und leiten daraus gleichzeitig den TypeScript-Typ ab. Damit schließen sie diese Lücke.
- Ausweichmanöver: Mit
any,as(einer Typzusicherung, mit der Entwickler dem Compiler widersprechen) oder// @ts-ignorelassen sich Prüfungen umgehen. In einer Codebasis voller solcher Stellen ist TypeScript kaum mehr als Dekoration.
Für Teams heißt das: Die Sprache allein hebt die Qualität nicht. Erst die Kombination aus strenger Konfiguration, Code-Reviews, die auf any und as achten, und Tests bringt den gewünschten Effekt. Wie Teams das im Alltag regeln, beschreibt der Beitrag zu TypeScript Best Practices.
TypeScript ohne Build-Schritt: Type Stripping in Node.js
Lange galt TypeScript als Sprache mit Mehraufwand: Vor jedem Start musste der Code übersetzt werden. Das hat sich geändert. Neuere Node.js-Versionen können TypeScript-Dateien direkt ausführen, indem sie die Typangaben beim Laden einfach entfernen. Dieses Verfahren heißt Type Stripping. Seit Node.js 22.6 gab es das hinter einem experimentellen Schalter, seit Node.js 22.18 und 23.6 ist es standardmäßig aktiv und seit 24.12 als stabil eingestuft.
node src/server.ts
Zwei Einschränkungen gehören dazu. Erstens prüft Node.js dabei keine Typen, es wirft sie nur weg. Die Prüfung übernimmt weiterhin tsc --noEmit im Editor oder in der CI-Pipeline. Zweitens funktioniert das nur mit Syntax, die sich rein durch Löschen entfernen lässt. Sprachmittel, die eigenen JavaScript-Code erzeugen, etwa enum oder Parameter-Eigenschaften im Konstruktor, werden nicht unterstützt. Die Compiler-Option erasableSyntaxOnly meldet solche Stellen schon beim Schreiben. Auch die Laufzeitumgebungen Deno und Bun führen TypeScript direkt aus.
Parallel hat Microsoft den Compiler in der Programmiersprache Go neu implementiert; diese Fassung ist im Juli 2026 als TypeScript 7 erschienen. Laut Microsoft beschleunigt sie vollständige Builds großer Projekte typischerweise um das 8- bis 12-Fache. Für Teams mit großen Codebasen ist das interessant, weil lange Prüfzeiten im Editor und in der CI bisher ein häufiger Kritikpunkt waren.
Bestehende JavaScript-Projekte schrittweise umstellen
Ein großes JavaScript-Projekt muss nicht auf einen Schlag umgeschrieben werden. TypeScript ist ausdrücklich für den schrittweisen Umstieg gebaut. Ein bewährter Weg sieht so aus:
- TypeScript einführen, ohne Dateien umzubenennen. Mit
allowJsundcheckJsin dertsconfig.jsonprüft der Compiler bereits bestehende.js-Dateien. Typen lassen sich dort über JSDoc-Kommentare angeben. - Dateien einzeln umstellen. Beginnen Sie mit Modulen, die wenige Abhängigkeiten haben, etwa Hilfsfunktionen oder Datenmodelle. Aus
.jswird.ts, und die Fehlermeldungen zeigen, wo Typen fehlen. - Grenzen zuerst typisieren. Den größten Nutzen bringen Typen für API-Antworten, Datenbankmodelle und die Schnittstellen zwischen Modulen.
- Strenge schrittweise erhöhen. Zuerst
noImplicitAny, dannstrictNullChecks, am Endestrictinsgesamt.
So sieht eine typisierte JavaScript-Datei mit JSDoc aus, die TypeScript bereits prüft:
// @ts-check
/**
* @param {number} netto
* @param {number} steuersatz
* @returns {number}
*/
export function bruttoPreis(netto, steuersatz) {
return netto * (1 + steuersatz);
}
Angenommen, ein Mittelständler pflegt ein internes Bestellportal mit einigen zehntausend Zeilen JavaScript. Ein realistischer Plan stellt zuerst die Kommunikation mit dem Backend auf Typen um, weil dort die meisten Fehler entstehen, und arbeitet sich dann über Monate in die Oberfläche vor – parallel zur normalen Weiterentwicklung. Für Bibliotheken ohne eigene Typen gibt es die Pakete unter @types, die die Community pflegt. Einen ausführlichen Leitfaden für React, Angular und Vue bietet der Infothek-Artikel JavaScript zu TypeScript migrieren.
Lohnt sich TypeScript für Ihr Projekt?
Für die meisten Projekte, die länger als ein paar Wochen leben und an denen mehr als eine Person arbeitet, lautet die Antwort ja. Der Aufwand für Typangaben ist geringer, als viele erwarten, weil die Inferenz den Großteil erledigt. Der Gewinn zeigt sich vor allem bei Änderungen: beim Umbenennen, beim Erweitern von Datenmodellen, bei der Einarbeitung neuer Teammitglieder, die sich über Typen und Autovervollständigung im Code orientieren.
TypeScript hat sich in der Webentwicklung als Standard etabliert. Angular setzt es seit Jahren voraus, für React, Vue und Svelte bietet etwa der Projektgenerator von Vite TypeScript-Vorlagen an, und Node.js-Frameworks wie NestJS erzeugen neue Projekte direkt in TypeScript. Auch KI-Assistenten beim Programmieren profitieren davon: Typen geben ihnen Kontext, und der Compiler fängt einen Teil ihrer Fehler ab.
Weniger klar ist der Nutzen bei kleinen Skripten, Prototypen für einen Nachmittag oder Projekten, deren Team TypeScript nur widerwillig einsetzt und es mit any umgeht. Dort kann JavaScript mit JSDoc-Typen und @ts-check ein guter Kompromiss sein.
Wer die Sprache von Grund auf lernen möchte, findet im Beitrag TypeScript 5 Grundlagen einen systematischen Einstieg in Typen, Funktionen und Klassen. Für die Umstellung bestehender Anwendungen bietet MARTINSFELD Beratung, Coaching und Seminare zur Migration nach TypeScript an.
Häufige Fragen zu TypeScript
Macht TypeScript die Anwendung langsamer?
Nein. Die Typen werden vor der Ausführung entfernt, im Browser oder auf dem Server läuft ganz normales JavaScript. Zeit kostet allenfalls die Typprüfung während der Entwicklung, nicht die Anwendung selbst.
Muss das ganze Projekt auf einmal umgestellt werden?
Nein. JavaScript- und TypeScript-Dateien können im selben Projekt nebeneinander bestehen. Viele Teams stellen über Monate Datei für Datei um und erhöhen die Strenge schrittweise.
Sind mit TypeScript noch Tests nötig?
Ja. Typen verhindern Fehler wie falsche Datentypen oder fehlende Felder, aber keine falsche Geschäftslogik. Tests und Typen ergänzen sich: Weil Typfehler schon vom Compiler abgefangen werden, können sich Tests auf das fachliche Verhalten konzentrieren.
Was ist der Unterschied zwischen interface und type?
Für Objekttypen sind beide weitgehend austauschbar. Interfaces lassen sich nachträglich erweitern und erscheinen in Fehlermeldungen stets unter ihrem Namen, Typ-Aliase können zusätzlich Union-Typen und andere zusammengesetzte Typen beschreiben. Wichtiger als die Wahl ist, dass ein Team sie einheitlich trifft.
Kategorien