{"canonical_url":"https://engineer.company/de/glossary/typescript/","content_markdown":"# TypeScript\n\n## Was es ist\n\nTypeScript ist eine Programmiersprache von Microsoft, die JavaScript um Typannotationen\nund einen Compiler namens `tsc` ergänzt, der sie prüft. Der Name wird zu TS abgekürzt;\ndie Dateien enden auf `.ts` oder, wenn sie JSX-Markup enthalten, auf `.tsx`.\nJavaScript-Syntax ist gültiges TypeScript, weshalb die Sprache als Obermenge von\nJavaScript bezeichnet wird. Der Compiler ist quelloffen und steht unter der Apache\nLicense 2.0.\n\nDie Typen bestehen nur für die Dauer der Prüfung. Gewöhnliche Typannotationen werden\nentfernt, wenn TypeScript JavaScript ausgibt; sie validieren nichts zur Laufzeit und\nerfordern keine Laufzeitbibliothek zur Typprüfung. Typannotationen ändern nicht, wie\nsich der JavaScript-Code bei der Ausführung verhält. Dieser eine Umstand erklärt\nNutzen und Grenzen zugleich: Die Typprüfung beurteilt die im Quelltext beschriebenen\nTypen; Daten, die während der Ausführung eintreffen, validiert sie nicht.\n\nDas Typsystem ist strukturell. Zwei Typen sind kompatibel, wenn ihre Strukturen\nzusammenpassen, unabhängig von ihren Namen. Das passt zu JavaScripts üblicher Praxis,\neinfache Objekte weiterzugeben; C# und Java vergleichen dagegen deklarierte Namen. Viele\nTypen werden abgeleitet, weshalb Annotationen vor allem an Funktionssignaturen und\nexportierten Werten stehen. An einigen Stellen ist das System zudem bewusst nicht\ntypsicher. `any` schaltet die Prüfung für einen Wert ab, und eine Typzusicherung mit\n`as` weist den Compiler an, sich auf die Typangabe der programmierenden Person zu\nverlassen. Beide verschwinden wie die übrigen Typangaben aus der Ausgabe.\n\nFür die Ausführung gibt es drei gängige Wege. `tsc` prüft ein Projekt und gibt\nJavaScript aus. Bundler wie esbuild entfernen die Typen ungeprüft und überlassen die\nPrüfung einem gesonderten Lauf von `tsc --noEmit`. Node.js führt seit v23.6.0 und\nv22.18.0 `.ts`-Dateien direkt aus, indem es die Typsyntax durch Leerraum ersetzt,\nebenfalls ohne Typprüfung, und akzeptiert nur Syntax, die sich so entfernen lässt.\nTypeScript 7.0, angekündigt im Juli 2026, ist eine native Go-Version des Compilers,\ndie nach Angaben des Teams vollständige Builds typischerweise 8- bis 12-mal schneller\nerledigt.\n\n## Warum es wichtig ist\n\nEin Team muss entscheiden, ob sich ein Build-Schritt und eine Typprüfung lohnen, weil\nsie Fehler vor der Ausführung finden. In einer Codebasis, die jede Woche von mehreren\nPersonen geändert wird, ist das meist der Fall. Beim Umbenennen eines Feldes werden\nalle Verwendungsstellen sichtbar; der Editor vervollständigt und erklärt Code anhand\nder Typen, und die Signatur eines Moduls wird zum Vertrag, den aufrufender Code nicht\nunbemerkt verletzen kann. Dem stehen eine Prüfung bei jedem Build, eine\nKonfigurationsdatei mit vielen Optionen und Typdefinitionen gegenüber, die mit den\nbeschriebenen Bibliotheken Schritt halten müssen.\n\nAm wichtigsten ist die Einstellung der Strenge. Das Flag `strict` aktiviert eine\nGruppe von Prüfungen, darunter `strictNullChecks` und `noImplicitAny`; das Handbuch\nbeschreibt das Ergebnis eher als Drehregler denn als Schalter. Seit TypeScript 6.0 ist\ndas Flag standardmäßig aktiviert, sodass ein neues Projekt mit strengen Prüfungen beginnt. In einem älteren Projekt\nkann es weiterhin auf false stehen; es später einzuschalten bedeutet, jede betroffene\nDatei durchzuarbeiten. Zwei nützliche Prüfungen gehören nicht zu dieser Gruppe und\nmüssen gesondert aktiviert werden: `noUncheckedIndexedAccess` und\n`exactOptionalPropertyTypes`.\n\nDas Entfernen der Typen setzt die Grenze. Liest ein Programm JSON aus einer\nNetzwerkanfrage, einer Datei, einer Warteschlange oder einem Formular, beruht die\nangenommene Datenstruktur allein auf der Aussage der programmierenden Person, denn\nbeim Eintreffen der Daten sind die Typen bereits weg. An den Grenzen ist deshalb eine\nValidierung zur Laufzeit nötig, idealerweise aus derselben Definition erzeugt wie die\nTypen, damit Prüfung und Typ nicht voneinander abweichen können. TypeScript sorgt im\nInneren eines Programms für Konsistenz und überlässt die Ränder dem Code.\n\nDie Typprüfung versorgt auch andere Werkzeuge. Ein Linter wie typescript-eslint kann\nTypinformationen beim Compiler abfragen, sodass eine Regel ein Promise meldet, auf\ndas niemand wartet, oder einen Wert vom Typ `any`, der sich durch ein Modul zieht.\nSo führt ein Verstoß gegen die eigenen Konventionen zu einer Fehlermeldung statt zu\neinem Review-Kommentar.\n\n## Wie es in der Praxis aussieht\n\nIn den auf dieser Website gezeigten Projekten wird die Verlässlichkeit von TypeScript\ndurch generierten Code und Werkzeuge gesichert, statt durch Konventionen. Drei Seiten\nzeigen, wie das geschieht.\n\nAuf einer Plattform wird der TypeScript-Client des Frontends nie von Hand geschrieben.\n[Er wird aus der Beschreibung der API selbst erzeugt](/de/portfolio/generated-the-api-contract-from-the-database-out/),\ndie Huma aus den Go-Typen ausgibt; diese folgen wiederum dem Datenbankschema und seinen\nFunktionen. Zum dokumentierten Implementierungsstand umfasste der Client 44.076\nZeilen. 61 gleichzeitig generierte Mock-Handler ließen die Frontend-Tests gegen den\ntatsächlichen Vertrag laufen statt gegen eine handgeschriebene Fixture. Jeder\nÜbergang hat seine eigene Prüfung. Eine Vertragsprüfung in CI vergleicht, was das\nFrontend sendet, mit dem, was die API erwartet, und lässt den Build bei Abweichungen\nfehlschlagen. Darunter untersucht eine Schemaprüfung die tatsächlichen Strukturen.\nErfasst werden optionale Body-Felder, bei denen fehlend und null leicht verwechselt\nwerden, und Enums in Abfrageparametern. Ändert sich ein Feld nur auf einer Seite,\nscheitert nun wenige Minuten nach der Änderung ein Build, statt dass nach der\nAuslieferung der Abweichung ein 422 im Browser erscheint. Im Gegenzug erreicht eine\nVertragsänderung die Typen des Clients nur, wenn die Kette erneut durchlaufen wird,\nund die erneute Generierung ist lästig.\n\nEine weitere Seite legt für sechs Sprachen, darunter TypeScript, denselben Maßstab\nan. [Jede von ESLint gemeldete Diagnose ist ein Fehler](/de/portfolio/set-a-zero-warnings-bar-across-six-languages/).\nEs gibt keine Warnstufe, in der sich etwas verstecken ließe, und Inline-Unterdrückungen\nsind verboten: Ein Befund muss behoben statt stummgeschaltet werden. Pre-Commit- und\nPre-Push-Hooks führen Linter und Tests aus; Längengrenzen für Funktionen und Dateien\nhalten Module lesbar.\n\nDie mit einer Sprache gelieferten Linter reichen nicht bis zu den projektspezifischen\nRegeln. Deshalb sicherten zum dokumentierten Implementierungsstand\n[fünfzehn eigene ESLint-Regeln](/de/portfolio/built-a-268-check-guard-engine-for-the-repo/)\ndie TypeScript-Muster dieses Repositorys. Sie gehörten zu einem Prüfsystem mit 274\nPrüfskripten, von denen 268 in den Commit-Hooks registriert waren. Die Prüfungen\nhatten selbst 146 Tests, denn eine defekte Prüfung lässt alles unbemerkt durch. Eine\nRegel betrifft Tests statt Typen: Ein Commit mit dem Präfix `fix:` muss einen Test\nenthalten, der ohne die Korrektur fehlschlägt. Die Review-Zeit verlagerte sich von\nformalen Fragen auf Entwurfsentscheidungen; im Gegenzug wurde das Committen langsam.\n\n## Wo es schiefgeht\n\nDie meisten TypeScript-Fehler entstehen, wenn den Typen über das hinaus vertraut wird,\nwas der Compiler sehen kann.\n\n**Ein als String typisiertes Feld ist zur Laufzeit undefined.** Die Daten kamen von\naußerhalb des Programms und erhielten einen Typ, statt geprüft zu werden. Die\nDOM-Bibliothek typisiert `res.json()` als Promise von `any`; deshalb akzeptiert der\nCompiler alles, was der Code mit dem Ergebnis anstellt. Eine Typzusicherung macht das\nVertrauen ausdrücklich, aber nicht sicher:\n\n```ts\nconst res = await fetch(\"/api/user\");\nconst user = (await res.json()) as User; // trusted, never checked\nuser.email.toLowerCase(); // TypeError if email is missing\n```\n\nExterne Daten sollten als `unknown` behandelt und an der Systemgrenze zur Laufzeit\nanhand eines Schemas validiert werden. Der Typ sollte aus diesem Schema erzeugt\nwerden, damit beide zusammenpassen.\nEine typgestützte Lint-Regel kann dann jedes `any` melden, das dennoch durchrutscht.\n\n**Code mit Typfehlern erreicht trotzdem die Produktion.** `tsc` schreibt auch dann\nJavaScript, wenn es Fehler meldet, weil `noEmitOnError` standardmäßig false ist.\nBundler und Node.js entfernen Typen, ohne sie überhaupt zu prüfen. `tsc --noEmit`\nsollte als verpflichtender Schritt in CI und im Pre-Commit-Hook laufen; ein Fehler-Exitcode\nmuss den Build scheitern lassen.\n\n**Ein Indexzugriff liefert undefined, das der Typ ausgeschlossen hatte.** Das Lesen\neines Array-Elements oder eines Schlüssels über eine Indexsignatur wird so typisiert,\nals sei der Wert immer vorhanden, selbst jenseits des Array-Endes.\nWird `noUncheckedIndexedAccess` aktiviert, fügt es solchen Zugriffen `undefined` hinzu und zwingt den Code,\ndamit umzugehen. Ergänzend sollte `exactOptionalPropertyTypes` aktiviert werden; es unterscheidet\neine fehlende Eigenschaft von einer auf `undefined` gesetzten.\n\n**Eine mit tsc kompilierbare Datei scheitert bei der Ausführung durch Node.js.** Das\nEntfernen der Typen beseitigt nur Syntax ohne Laufzeitbedeutung. Enums und Namespaces,\ndie Werte enthalten, lassen Node.js mit `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` abbrechen.\nEin ohne das Schlüsselwort `type` importierter Typ gilt als Wertimport und scheitert\nzur Laufzeit. Mit `erasableSyntaxOnly` und `verbatimModuleSyntax` meldet der Compiler\nbeides vor Node.js. Für Typen sollte `import type` verwendet werden; Enums lassen sich\ndurch mit `as const` markierte Objektliterale ersetzen.\n\n## Weiterführende Lektüre\n\n- [TypeScript Documentation](https://www.typescriptlang.org/docs/) — Handbuch,\n  Referenzseiten und Versionshinweise, gepflegt vom TypeScript-Team.\n- [The Basics](https://www.typescriptlang.org/docs/handbook/2/basic-types.html) — das\n  Handbuchkapitel über statische Prüfung, Ausgabe trotz Fehlern, entfernte Typen und\n  Strenge.\n- [TSConfig Reference: strict](https://www.typescriptlang.org/tsconfig/#strict) — jede\n  Compileroption mit ihrem Standardwert, einschließlich der durch strict aktivierten\n  Prüfungen.\n- [Type Compatibility](https://www.typescriptlang.org/docs/handbook/type-compatibility.html)\n  — strukturelle Subtypisierung und die Stellen, an denen das Typsystem bewusst nicht\n  typsicher ist.\n- [Node.js: Modules: TypeScript](https://nodejs.org/api/typescript.html) — das Entfernen\n  von Typen, die dabei abgewiesene Syntax und die von Node.js empfohlenen\n  Compilereinstellungen.\n- [Linting with Type Information](https://typescript-eslint.io/getting-started/typed-linting/)\n  — wie typescript-eslint Lint-Regeln Zugang zur Typprüfung gibt.\n\n\u003chttps://engineer.company/de/glossary/typescript/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Was TypeScript prüft und entfernt, wie streng es eingestellt wird, wie Node.js es ausführt und wo seine Typen ein Programm nicht mehr schützen.","formats":{"gemtext":"https://engineer.company/de/glossary/typescript/index.gmi","gopher":"https://engineer.company/de/glossary/typescript/gophermap","html":"https://engineer.company/de/glossary/typescript/","json":"https://engineer.company/de/glossary/typescript/index.json","markdown":"https://engineer.company/de/glossary/typescript/index.md","pdf":"https://engineer.company/de/glossary/typescript/index.pdf"},"kind":"page","language":"de","title":"Was ist TypeScript?","url":"https://engineer.company/de/glossary/typescript/","version":1}