TypeScript-Einführung
TypeScript ist eine von Microsoft entwickelte Open-Source-Programmiersprache. Sie ist eine Obermenge von JavaScript, die, obwohl vollständig mit der JavaScript-Syntax kompatibel, ein optionales statisches Typsystem und klassenbasierte objektorientierte Programmierfunktionen hinzufügt.
TypeScript-Code wird letztendlich zu reinem JavaScript kompiliert und kann in jeder Umgebung ausgeführt werden, die JavaScript unterstützt, einschließlich Browsern, Node.js und mobilen Plattformen.

Warum TypeScript?
JavaScript ist eine dynamisch typisierte Sprache; der Typ einer Variablen kann erst zur Laufzeit bestimmt werden.
Diese Flexibilität funktioniert gut in kleinen Projekten, aber mit wachsender Projektgröße treten die Probleme allmählich zutage:
| Problemszenario | JavaScripts Dilemma | TypeScripts Lösung |
|---|---|---|
| Falscher Typ wird an Funktionsparameter übergeben | Fehler treten erst zur Laufzeit auf, frühzeitig schwer zu erkennen | Fehler treten zur Kompilierzeit auf, mit Echtzeit-Hinweisen in der IDE |
| Zugriff auf nicht vorhandene Eigenschaften | Gibt zurückundefined, das Verhalten ist unvorhersehbar | Der Compiler meldet direkt einen Fehler und weigert sich, ihn durchzulassen |
| Refactoring großer Projekte | Eine Stelle ändern, keine Ahnung, was dadurch kaputtgeht | Das Typsystem verfolgt automatisch alle Referenzen |
| Teamzusammenarbeit | Welche Parameter eine Funktion akzeptiert und was sie zurückgibt, hängt vollständig von Kommentaren oder Dokumentation ab | Typsignaturen dienen als Dokumentation, mit IDE-Autovervollständigung |
| Lesbarkeit des Codes | Man kann die Datenstruktur nicht direkt aus einer Funktionsdefinition erkennen | Interfaces und Typaliase machen die Datenstruktur auf einen Blick klar |
TypeScripts wesentliches Ziel ist es nicht, JavaScript zu ersetzen, sondern groß angelegte JavaScript-Projekte handhabbar und wartbar zu machen. Es ist JavaScripts "Sicherheitsnetz", kein Konkurrent.
Betrachten wir das anschaulichste Beispiel:
Beispiel
function greet(name) {
return "Hello, " + name.toUpperCase();
}
greet(123); // Laufzeitfehler: name.toUpperCase ist keine Funktion
Beispiel
function greet(name: string): string {
return "Hello, " + name.toUpperCase();
}
greet(123); // Kompilierungsfehler: Argument vom Typ 'number' ist nicht dem Parameter vom Typ 'string' zuweisbar.
greet("example"); // Korrekt: Hello, EXAMPLE
Beziehung zwischen TypeScript und JavaScript
Die Beziehung zwischen TypeScript und JavaScript lässt sich in einem Satz zusammenfassen:TypeScript ist eine Obermenge von JavaScript, was bedeutet, dass aller gültige JavaScript-Code auch gültiger TypeScript-Code ist.
Illustration der Mengenbeziehung
JavaScript (aller JS-Code)
⊂ TypeScript (JS + Typsystem + neue Funktionen)
⊂ Kompiliertes Ergebnis (Standard-JavaScript, kann in jeder Umgebung ausgeführt werden)
Hauptunterschiede zwischen den beiden:
| Vergleichspunkt | JavaScript | TypeScript |
|---|---|---|
| Typsystem | Dynamische Typisierung, zur Laufzeit bestimmt | Statische Typisierung, zur Kompilierzeit geprüft (optional) |
| Ausführungsmethode | Direkt im Browser / Node.js ausführen | Muss vor der Ausführung zu JS kompiliert werden |
| Zeitpunkt der Fehlererkennung | Laufzeit | Kompilierzeit (früh erkannt) |
| IDE-Unterstützung | Grundlegende Autovervollständigung | Starke Typinferenz, präzise Vervollständigung, Refactoring-Unterstützung |
| Lernkurve | Vergleichsweise sanft | Erfordert zusätzliches Erlernen des Typsystems |
| Kompatibilität mit vorhandenem JS | — | Vollständig kompatibel, schrittweise Migration möglich |
| Dateiendung | .js | .tsoder.tsx(einschließlich JSX) |
TypeScript unterstützt "schrittweise Einführung": Du musst nicht das gesamte Projekt auf einmal neu schreiben. Du kannst zunächst
.jsändern.ts, dann nach und nach Typen zu wichtigen Modulen hinzufügen, und vorhandener Code läuft weiterhin wie gewohnt.
Kernfunktionen
TypeScript führt ein vollständiges Typsystem ein, das auf JavaScript aufbaut. Die folgenden sind die am häufigsten verwendeten Kernfunktionen.
Grundlegende Typannotationen
Deklariere Typen nach Variablen, Funktionsparametern und Rückgabewerten mit einem Doppelpunkt; dies ist die grundlegendste Syntax von TypeScript.
Beispiel
let age: number = 25;
let username: string = "example";
let isActive: boolean = true;
// Array-Typen, zwei äquivalente Möglichkeiten
let scores: number[] = [90, 85, 92];
let tags: Array<string> = ["typescript", "javascript"];
// Tupel: Array mit fester Länge und Typen
let point: [number, number] = [10, 20];
let entry: [string, number] = ["EXAMPLE", 100];
// Funktion: Parametertypen + Rückgabetyp
function add(a: number, b: number): number {
return a + b;
}
// void: Funktion hat keinen Rückgabewert
function log(msg: string): void {
console.log(msg);
}
// Optionaler Parameter: ? nach dem Parameternamen hinzufügen
function greet(name: string, title?: string): string {
return title ? `${title} ${name}` : name;
}
console.log(greet("EXAMPLE")); // Ausgabe: EXAMPLE
console.log(greet("example", "Mr.")); // Ausgabe: Mr. example
Benutzeroberfläche
Ein Interface wird verwendet, um die "Form" eines Objekts zu beschreiben und festzulegen, welche Eigenschaften und Methoden das Objekt haben sollte.
Beispiel
interface User {
id: number; // Erforderlich
name: string; // Erforderlich
email?: string; // Optional, mit ? gekennzeichnet
readonly role: string; // Schreibgeschützt, kann nach der Zuweisung nicht geändert werden
}
// Funktionsparameter verwendet den Interface-Typ
function printUser(user: User): void {
console.log(`ID: ${user.id}, Name: ${user.name}`);
if (user.email) {
console.log(`E-Mail: ${user.email}`);
}
}
const admin: User = {
id: 1,
name: "EXAMPLE",
email: "example@example.com",
role: "admin",
};
printUser(admin);
// Ausgabe: ID: 1, Name: EXAMPLE
// Ausgabe: E-Mail: example@example.com
// admin.role = "user"; // Fehler: Zuweisung zu 'role' nicht möglich, da es sich um eine schreibgeschützte Eigenschaft handelt.
// Interface-Vererbung
interface AdminUser extends User {
permissions: string[];
}
Typalias
Typaliase verwendentypedas Schlüsselwort zum Erstellen und können Aliase für jeden Typ definieren, einschließlich komplexer Strukturen wie Union-Typen und Intersection-Typen.
Beispiel
type ID = string | number;
let userId: ID = "abc-123"; // Gültig
userId = 456; // Ebenfalls gültig
// Literal-Typ: beschränkt die Variable auf bestimmte Werte
type Direction = "up" | "down" | "left" | "right";
type Status = "pending" | "active" | "inactive";
function move(dir: Direction): void {
console.log(`Moving ${dir}`);
}
move("up"); // Korrekt
// move("diagonal"); // Fehler: nicht innerhalb des Literalbereichs
// Intersection-Typ: kombiniert mehrere Typen
type WithTimestamp = {
createdAt: Date;
updatedAt: Date;
};
type UserRecord = User & WithTimestamp; // Hat alle Eigenschaften von User und WithTimestamp
// Funktions-Typalias
type Transformer<T, U> = (input: T) => U;
const toNumber: Transformer<string, number> = (s) => parseInt(s, 10);
Generika
Generics ermöglichen das Schreiben wiederverwendbarer Komponenten unter Beibehaltung der Typsicherheit. Man kann sich Generics als "Typvariablen" vorstellen – übergeben Sie beim Verwenden konkrete Typen.
Beispiel
function firstNumber(arr: number[]): number {
return arr[0];
}
// Mit Generics: T ist ein Typparameter, der konkrete Typ wird zur Aufrufzeit bestimmt
function first<T>(arr: T[]): T {
return arr[0];
}
const n = first<number>([1, 2, 3]); // n ist vom Typ number
const s = first<string>(["a", "b"]); // s ist vom Typ string
const inferred = first([true, false]); // TypeScript leitet T automatisch als boolean ab
// Generisches Interface
interface ApiResponse<T> {
data: T;
status: number;
message: string;
}
// Generisches Interface verwenden
const userResponse: ApiResponse<User> = {
data: { id: 1, name: "EXAMPLE", role: "admin" },
status: 200,
message: "success",
};
// Generische Einschränkung: T muss eine id-Eigenschaft haben
function getById<T extends { id: number }>(items: T[], id: number): T | undefined {
return items.find(item => item.id === id);
}
Enum
Enums werden verwendet, um eine Reihe benannter Konstanten zu definieren, wodurch "magische Zahlen" oder "magische Strings" im Code aussagekräftig werden.
Beispiel
enum Direction {
Nach oben, // 0
Down, // 1
Left, // 2
Rechts, // 3
}
console.log(Direction.Up); // Ausgabe: 0
console.log(Direction[0]); // Ausgabe: "Up" (umgekehrte Zuordnung)
// String-Enum (empfohlen, Werte sind beim Debuggen besser lesbar)
enum Color {
Red = "RED",
Green = "GREEN",
Blue = "BLUE",
}
function paint(color: Color): void {
console.log(`Painting in ${color}`);
}
paint(Color.Red); // Ausgabe: Painting in RED
// paint("red"); // Fehler: String "red" ist nicht vom Typ Color
// const enum: nach der Kompilierung inline eingefügt, wodurch der Laufzeit-Overhead reduziert wird
const enum HttpStatus {
Gut = 200,
NotFound = 404,
InternalError = 500,
}
const status: HttpStatus = HttpStatus.OK; // Nach der Kompilierung direkt durch die Zahl 200 ersetzt
Typinferenz
TypeScript erfordert nicht, dass für jede Variable Typen manuell annotiert werden; der Compiler leitet sie basierend auf dem zugewiesenen Wert automatisch ab.
Beispiel
let count = 0; // Als number abgeleitet
let name = "EXAMPLE"; // Als string abgeleitet
let flag = true; // Als boolean abgeleitet
// Abgeleiteter Array-Elementtyp
let numbers = [1, 2, 3]; // Als number[] abgeleitet
// Rückgabetyp der Funktion ableiten
function double(n: number) { // Rückgabetyp automatisch als number abgeleitet
return n * 2;
}
// Inferenz für Objektliterale
const config = {
host: "localhost", // string
port: 3000, // number
debug: false, // boolean
};
// config.port = "3000"; // Fehler: Typ 'string' ist nicht dem Typ 'number' zuweisbar.
Ein praktischer Tipp: Funktionsparameter benötigen normalerweise explizite Typannotationen (weil Aufrufer Typen nicht aus Parameterwerten ableiten können), während lokale Variablen und Rückgabewerte innerhalb des Funktionskörpers sich größtenteils auf Inferenz verlassen können – es ist nicht nötig, alles manuell zu annotieren.
Klassen und Zugriffsmodifikatoren
TypeScript unterstützt die ES6-Klassensyntax vollständig und fügtpublic、private、protected、readonlyvier Zugriffsmodifikatoren hinzu.
Beispiel
readonly name: string; // Schreibgeschützt, kann nach der Initialisierung nicht geändert werden
private age: number; // Privat, nur innerhalb der Klasse zugänglich
protected species: string; // Protected, für Unterklassen zugänglich
constructor(name: string, age: number, species: string) {
this.name = name;
this.age = age;
this.species = species;
}
// öffentliche Methode (standardmäßig öffentlich, kann weggelassen werden)
public introduce(): string {
return `IIch bin ${this.name}, ein ${this.species}.`;
}
// Getter: Methode wie eine Eigenschaft aufrufen
get info(): string {
return `${this.name} (${this.age} Jahre alt)`;
}
}
class Dog extends Animal {
private breed: string;
constructor(name: string, age: number, breed: string) {
super(name, age, "Canis lupus familiaris"); // Ruft den Konstruktor der Elternklasse auf
this.breed = breed;
}
// Unterklasse kann auf geschützte Eigenschaften zugreifen
describe(): string {
return `${this.name} ist ein ${this.species}, Rasse: ${this.breed}`;
}
}
const dog = new Dog("EXAMPLE", 3, "Labrador");
console.log(dog.introduce()); // Ausgabe: I'm EXAMPLE, a Canis lupus familiaris.
console.log(dog.info); // Ausgabe: EXAMPLE (3 Jahre alt)
// console.log(dog.age); // Fehler: Auf eine private Eigenschaft kann nicht von außen zugegriffen werden
Dekorator
Decorators sind eine Metaprogrammierungssyntax, mit der zusätzliches Verhalten an Klassen, Methoden und Eigenschaften angehängt wird; häufig in Frameworks wie Angular, NestJS usw. zu sehen.
TypeScript 5.0 hat Decorators als offiziellen Standard implementiert (Stage-3-Vorschlag), sodass dasexperimentalDecoratorsFlag nicht mehr erforderlich ist.
Beispiel
function sealed(constructor: Function) {
Object.seal(constructor); // Verhindert das Hinzufügen neuer Eigenschaften
Object.seal(constructor.prototype);
}
// Methoden-Decorator: kann für Protokollierung, Berechtigungsprüfungen usw. verwendet werden.
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const original = descriptor.value;
descriptor.value = function (...args: any[]) {
console.log(`Calling ${propertyKey} with args:`, args);
const result = original.apply(this, args);
console.log(`${propertyKey} returned:`, result);
return result;
};
}
@sealed
class Calculator {
@log
add(a: number, b: number): number {
return a + b;
}
}
const calc = new Calculator();
calc.add(1, 2);
// Ausgabe: Calling add with args: [ 1, 2 ]
// Ausgabe: add returned: 3
Anwendungsbereiche
Dank seiner vollständigen Kompatibilität mit JavaScript kann TypeScript fast überall eingesetzt werden, wo JavaScript läuft, und bringt zusätzliche Vorteile in großen Projekten.
Front-End-Webentwicklung
Dies ist das am weitesten verbreitete Szenario für TypeScript. Alle drei großen Frontend-Frameworks bieten erstklassige Unterstützung für TypeScript:
| Framework | TypeScript-Unterstützung | Typisches Szenario |
|---|---|---|
| Angular | Offizielle Sprache, standardmäßig TypeScript, nicht zu vermeiden. | Enterprise-SPA, Admin-Systeme |
| React | Offiziell bereitgestellt@types/react, Create React App und Vite enthalten beide TypeScript-Vorlagen | E-Commerce, Content-Plattformen, Admin-/Backend-Anwendungen |
| Vue | Der Vue-3-Kerncode wurde in TypeScript neu geschrieben, und die Composition API verbessert die TypeScript-Freundlichkeit erheblich | Kleine bis mittlere Projekte, progressive Migration |
| Next.js / Nuxt | Integrierte TypeScript-Unterstützung, standardmäßig für neue Projekte aktiviert | Full-Stack-SSR/SSG-Anwendungen |
Backend-Entwicklung mit Node.js
TypeScript ist in der Node.js-Backend-Entwicklung ebenso weit verbreitet.NestJSEs ist derzeit das beliebteste TypeScript-Backend-Framework, mit einer modularen Architektur ähnlich wie Angular, integrierter Dependency Injection und Decorator-Unterstützung.
Darüber hinaus,DenoDie Laufzeitumgebung unterstützt TypeScript von Anfang an nativ und kann ohne jegliche Konfiguration direkt ausgeführt werden.tsDateien.BunBietet außerdem integrierte TypeScript-Unterstützung.
Kommandozeilen-Tools und Skripte
Mit Hilfe vonts-node、tsxund anderen Tools kann TypeScript-Code direkt ohne Vorkompilierung ausgeführt werden, was ihn ideal für das Schreiben von Build-Skripten und CLI-Tools macht.
Mobil und plattformübergreifend
React Nativeunterstützt TypeScript vollständig, und viele mobile Unternehmensanwendungen (wie Microsoft Office Mobile, Shopify usw.) verwenden diesen Technologie-Stack.ExpoDie neue Projektvorlage basiert standardmäßig ebenfalls auf TypeScript.
Spieleentwicklung und Grafik
Babylon.js(Microsofts 3D-Engine) ist vollständig in TypeScript geschrieben und behandelt TypeScript-Typdefinitionen als First-Class-Bürger.Phaserund andere 2D-Spiel-Engines bieten ebenfalls vollständige Typdefinitionen.
Entwicklungsgeschichte
Die Entstehung und das Wachstum von TypeScript sind eng mit der Entwicklung des JavaScript-Ökosystems verbunden, und jede Hauptversion wird von klaren technischen Anforderungen angetrieben.
Ursprünge (2010 - 2012)
Die Geschichte von TypeScript begann mit einer technischen Herausforderung innerhalb von Microsoft: Wie lassen sich große JavaScript-Projekte wartbar machen?
DesignerAnders Hejlsbergist eine Branchenlegende – der Chefarchitekt von C# und der Schöpfer von Turbo Pascal und Delphi. Er begann um 2010 mit dem Entwurf dieser Sprache, mit dem Kernziel, statische Typprüfung einzuführen, ohne die JavaScript-Kompatibilität zu brechen.
Ein weiterer Hintergrund für Microsofts Einführung von TypeScript war die Veröffentlichung von Windows 8 – Anwendungen konnten mit HTML + JavaScript entwickelt werden, und Microsoft hoffte, .NET-Programmierer anzuziehen, daher wurden viele Syntaxmerkmale von TypeScript absichtlich ähnlich zu C# und .NET gehalten.
Im Oktober 2012 wurde TypeScript 0.8 öffentlich veröffentlicht, nach etwa zwei Jahren interner Entwicklung bei Microsoft.
Frühe Versionen (2013 - 2015)
| Zeit | Version | Wichtige Ereignisse |
|---|---|---|
| 2013-06 | 0.9 | Offizielle stabile Veröffentlichung, deutlich verbesserte Leistung, bessere IDE-Integration |
| 2014-04 | 1.0 | Erste offizielle stabile Version, die Klassen, Schnittstellen, Module einführte und die Kompilierung zu Standard-JavaScript unterstützte |
| 2014-07 | — | Der Quellcode des TypeScript-Compilers wurde als Open Source veröffentlicht, auf GitHub gehostet und Community-Beiträge werden angenommen |
| 2015-04 | — | Microsoft veröffentlicht Visual Studio Code mit tief integrierter TypeScript-Unterstützung; beide ergänzen sich gegenseitig |
| 2015-07 | 1.5 | Einführung der Unterstützung für ES6-Modulsyntax, Decorators (experimentell) und Namespaces |
Schnelles Wachstum (2016 - 2019)
Diese Phase war ein entscheidender Zeitraum dafür, dass TypeScript von einem Nischenwerkzeug zum Mainstream wurde, wobei die zentrale Antriebskraft aus Entscheidungen im Framework-Ökosystem kam.
| Zeit | Version / Ereignis | Bedeutung des Meilensteins |
|---|---|---|
| 2016-09 | TypeScript 2.0 | Einführung nicht-nullbarer Typen (--strictNullChecks), eine der wichtigsten Funktionen der Typsicherheit von TypeScript; führte diskriminierte Union-Typen ein |
| 2016 | Angular 2 veröffentlicht | Das Google-Angular-Team kündigte an, TypeScript als offizielle Entwicklungssprache zu übernehmen, und rückte TypeScript damit in den Blick der Öffentlichkeit |
| 2017 | TypeScript 2.x-Serie | Bedingte Typen, gemappte Typen und das Schlüsselwort infer wurden nacheinander eingeführt, was die Ausdrucksstärke des Typsystems erheblich verbesserte |
| 2018-07 | TypeScript 3.0 | Project References, Unterstützung großer Monorepos; führte den unknown-Typ ein (ein sichererer Top-Typ als any) |
| 2019 | DefinitelyTyped | Von der Community gepflegtes Repository für Typdefinitionen DefinitelyTyped (@types/*) deckt über 7,000 Pakete ab und umfasst damit im Wesentlichen alle gängigen npm-Bibliotheken |
Reife und Verbreitung (2020 - 2022)
| Zeit | Version / Ereignis | Wichtige Inhalte |
|---|---|---|
| 2020-08 | TypeScript 4.0 | Variadische Tupeltypen, beschriftete Tupelelemente; deutlich verbesserte Editor-Erfahrung |
| 2021 | TypeScript 4.x-Serie | Template-Literal-Typen, erweiterte integrierte Utility-Typen,noImplicitOverrideund weitere Verbesserungen im Strict-Modus |
| 2022 | State of JS-Umfrage | Die TypeScript-Nutzungsrate übertraf erstmals reines JavaScript und wurde damit zur beliebtesten Superset-Sprache im JS-Ökosystem |
| 2022 | Vue 3 / Vite-Einführung | Vue-3-Kern in TypeScript neu geschrieben, kombiniert mit Vite, um die TypeScript-Erfahrung im Frontend-Engineering auf ein neues Niveau zu heben |
Moderne Ära (2023 - Gegenwart)
| Zeit | Version | Hauptmerkmale |
|---|---|---|
| 2023-03 | TypeScript 5.0 | Moderne Dekoratoren (Stage 3 Standard), const-Typparameter, alle Enums zu Union-Enums aufgewertet, mit erheblichen Leistungsverbesserungen |
| 2023-08 | TypeScript 5.2 | Einführung der expliziten Ressourcenverwaltung (usingSchlüsselwort), das das Problem der deterministischen Bereinigung von Ressourcen wie Datenbankverbindungen und Dateihandles löst |
| 2024-03 | TypeScript 5.4 | Verbesserte Typverengung in Closures,NoInferUtility-Typen |
| 2024-06 | TypeScript 5.5 | Typ-Prädikat-Inferenz, Syntaxprüfung regulärer Ausdrücke, sodass das Typsystem Codelogik präziser versteht |
| 2024-11 | TypeScript 5.7 | Unterstützung für--target es2024, zuverlässigere Erkennung nicht initialisierter Variablen |
| 2025-03 | TypeScript 5.8 | Verbesserte Rückgabewertprüfung für bedingte und indizierte Zugriffstypen; unterstützt unter--module nodenextviarequire()Laden von ESM-Modulen (erfordert Node.js 22+) |
Zukunftsausblick: Neuimplementierung des Compilers in Go
Anfang 2025 kündigte Microsoft eine bedeutende Entscheidung an: die Neuimplementierung des TypeScript-Compilers in Go unter dem ProjektcodenamenCorsa。
In der offiziellen Erklärung heißt es, dass der neu implementierte Compiler eine Leistungsverbesserung von mehr als 10x liefern soll, wodurch Build-Zeiten für große Projekte von Minuten auf Sekunden reduziert werden.
Dem Plan zufolge wird die Go-Version offiziell in TypeScript 7.x veröffentlicht, während die aktuellen TypeScript-Versionen 5.x / 6.x weiterhin normal iteriert und gewartet werden. Die Neuimplementierung soll bis Ende 2025 abgeschlossen sein.
Diese Neuimplementierung wird die Syntax oder das Typsystem der TypeScript-Sprache selbst nicht ändern; es ist ein transparentes Upgrade für Entwickler – Ihr Code muss nicht geändert werden, lediglich die Kompilierungsgeschwindigkeit wird deutlich verbessert.
Vergleich zwischen TypeScript und anderen statisch typisierten Sprachen
Wenn Sie einen Hintergrund in anderen stark typisierten Sprachen haben, kann der folgende Vergleich Ihnen helfen, die Designphilosophie von TypeScript schnell zu verstehen.
| Vergleichspunkt | TypeScript | Java / C# | Go |
|---|---|---|---|
| Typsystem | Strukturelle Typisierung (Duck-Typing) | Nominale Typisierung (Vererbungsbeziehungen müssen explizit deklariert werden) | Strukturelle Typisierung (implizite Interfaces) |
| Null-Sicherheit | AktivierungstrictNullChecksunterstützt es anschließend | Java erfordert Annotationen oder Optional, C# 8+ unterstützt | Durch Fehlerwerte und Nil-Prüfungen |
| Generika | Unterstützt, Syntax ähnlich zu Java/C# | Unterstützt, Java hat Einschränkungen durch Type Erasure | Go 1.18+ unterstützt es, mit einfacherer Syntax |
| Kompilierte Ausgabe | JavaScript (läuft in JS-Umgebungen) | Bytecode (läuft auf JVM / CLR) | Nativer Maschinencode |
| Laufzeit-Typprüfung | Keine (Typinformationen werden nach der Kompilierung gelöscht) | Ja (Reflexionsmechanismus) | Keine |
| Lernkurve | Freundlich für JS-Entwickler, kann schrittweise eingeführt werden | Für Anfänger steiler | Relativ einfach, mäßige Lernkurve |
TypeScript verwendetein strukturelles Typsystem(Structural Typing): Solange zwei Typen dieselbe "Form" haben, gelten sie als kompatibel, ohne dass Vererbungsbeziehungen explizit deklariert werden müssen. Dies unterscheidet sich grundlegend von der nominalen Typisierung von Java/C# und ist auch der Hauptgrund, warum TypeScript nahtlos mit JavaScript zusammenarbeiten kann.
Einschränkungen von TypeScript
TypeScript ist keine Wunderwaffe; seine Grenzen zu verstehen, ist ebenso wichtig.
| Einschränkung | Beschreibung | Wie man damit umgeht |
|---|---|---|
| Keine Typen zur Laufzeit | Typinformationen werden nach der Kompilierung vollständig gelöscht, und auf Typen kann zur Laufzeit für Beurteilungen nicht vertraut werden | Verwenden Sie Bibliotheken wiezod、io-tswenn Laufzeitvalidierung erforderlich ist |
| Kompilierungsschritt | Fügt im Vergleich zu reinem JS einen Kompilierungsschritt hinzu, was die Projektkomplexität erhöht | Moderne Build-Tools (Vite, esbuild) kommen damit bereits gut zurecht |
| any-Typ-Notlösung | Übermäßige Verwendung vonanymacht die Typprüfung unwirksam | AktivierennoImplicitAnyundstrictModus, kombiniert mit ESLint-Regeln |
| Hürde der Typ-Gymnastik | Komplexe bedingte Typen und Mapped Types sind nicht anfängerfreundlich | Der meiste Business-Code erfordert keine fortgeschrittenen Typen; gehen Sie es Schritt für Schritt an |
| Unterstützung für Drittanbieter-Bibliotheken | Einige ältere Bibliotheken besitzen keine Typdefinitionen, sodass Sie die .d.ts selbst schreiben müssen | Prüfe zuerst@types/*; falls tatsächlich nicht vorhanden, schreiben Sie die Deklarationsdatei manuell |