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:

ProblemszenarioJavaScripts DilemmaTypeScripts Lösung
Falscher Typ wird an Funktionsparameter übergebenFehler treten erst zur Laufzeit auf, frühzeitig schwer zu erkennenFehler treten zur Kompilierzeit auf, mit Echtzeit-Hinweisen in der IDE
Zugriff auf nicht vorhandene EigenschaftenGibt zurückundefined, das Verhalten ist unvorhersehbarDer Compiler meldet direkt einen Fehler und weigert sich, ihn durchzulassen
Refactoring großer ProjekteEine Stelle ändern, keine Ahnung, was dadurch kaputtgehtDas Typsystem verfolgt automatisch alle Referenzen
TeamzusammenarbeitWelche Parameter eine Funktion akzeptiert und was sie zurückgibt, hängt vollständig von Kommentaren oder Dokumentation abTypsignaturen dienen als Dokumentation, mit IDE-Autovervollständigung
Lesbarkeit des CodesMan kann die Datenstruktur nicht direkt aus einer Funktionsdefinition erkennenInterfaces 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

// JavaScript: Fehler tritt erst zur Laufzeit auf
function greet(name) {
    return "Hello, " + name.toUpperCase();
}

greet(123); // Laufzeitfehler: name.toUpperCase ist keine Funktion

Beispiel

// TypeScript: Fehler können zur Kompilierzeit gefunden werden
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:

VergleichspunktJavaScriptTypeScript
TypsystemDynamische Typisierung, zur Laufzeit bestimmtStatische Typisierung, zur Kompilierzeit geprüft (optional)
AusführungsmethodeDirekt im Browser / Node.js ausführenMuss vor der Ausführung zu JS kompiliert werden
Zeitpunkt der FehlererkennungLaufzeitKompilierzeit (früh erkannt)
IDE-UnterstützungGrundlegende AutovervollständigungStarke Typinferenz, präzise Vervollständigung, Refactoring-Unterstützung
LernkurveVergleichsweise sanftErfordert 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

// Grundlegende Typen: number, string, boolean, null, undefined, symbol, bigint
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 definieren: Beschreibe die Struktur eines Benutzerobjekts
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

// Union-Typ: Variable kann einen von mehreren Typen annehmen
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

// Ohne Generics: kann nur den number-Typ verarbeiten
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

// Numerisches Enum (standardmäßig inkrementiert ab 0)
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

// TypeScript leitet Variablentypen automatisch ab, keine explizite Annotation erforderlich
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

class Animal {
    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

// Klassen-Decorator: wird ausgeführt, wenn die Klasse definiert wird
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:

FrameworkTypeScript-UnterstützungTypisches Szenario
AngularOffizielle Sprache, standardmäßig TypeScript, nicht zu vermeiden.Enterprise-SPA, Admin-Systeme
ReactOffiziell bereitgestellt@types/react, Create React App und Vite enthalten beide TypeScript-VorlagenE-Commerce, Content-Plattformen, Admin-/Backend-Anwendungen
VueDer Vue-3-Kerncode wurde in TypeScript neu geschrieben, und die Composition API verbessert die TypeScript-Freundlichkeit erheblichKleine bis mittlere Projekte, progressive Migration
Next.js / NuxtIntegrierte TypeScript-Unterstützung, standardmäßig für neue Projekte aktiviertFull-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)

ZeitVersionWichtige Ereignisse
2013-060.9Offizielle stabile Veröffentlichung, deutlich verbesserte Leistung, bessere IDE-Integration
2014-041.0Erste 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-071.5Einfü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.

ZeitVersion / EreignisBedeutung des Meilensteins
2016-09TypeScript 2.0Einführung nicht-nullbarer Typen (--strictNullChecks), eine der wichtigsten Funktionen der Typsicherheit von TypeScript; führte diskriminierte Union-Typen ein
2016Angular 2 veröffentlichtDas Google-Angular-Team kündigte an, TypeScript als offizielle Entwicklungssprache zu übernehmen, und rückte TypeScript damit in den Blick der Öffentlichkeit
2017TypeScript 2.x-SerieBedingte Typen, gemappte Typen und das Schlüsselwort infer wurden nacheinander eingeführt, was die Ausdrucksstärke des Typsystems erheblich verbesserte
2018-07TypeScript 3.0Project References, Unterstützung großer Monorepos; führte den unknown-Typ ein (ein sichererer Top-Typ als any)
2019DefinitelyTypedVon 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)

ZeitVersion / EreignisWichtige Inhalte
2020-08TypeScript 4.0Variadische Tupeltypen, beschriftete Tupelelemente; deutlich verbesserte Editor-Erfahrung
2021TypeScript 4.x-SerieTemplate-Literal-Typen, erweiterte integrierte Utility-Typen,noImplicitOverrideund weitere Verbesserungen im Strict-Modus
2022State of JS-UmfrageDie TypeScript-Nutzungsrate übertraf erstmals reines JavaScript und wurde damit zur beliebtesten Superset-Sprache im JS-Ökosystem
2022Vue 3 / Vite-EinführungVue-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)

ZeitVersionHauptmerkmale
2023-03TypeScript 5.0Moderne Dekoratoren (Stage 3 Standard), const-Typparameter, alle Enums zu Union-Enums aufgewertet, mit erheblichen Leistungsverbesserungen
2023-08TypeScript 5.2Einführung der expliziten Ressourcenverwaltung (usingSchlüsselwort), das das Problem der deterministischen Bereinigung von Ressourcen wie Datenbankverbindungen und Dateihandles löst
2024-03TypeScript 5.4Verbesserte Typverengung in Closures,NoInferUtility-Typen
2024-06TypeScript 5.5Typ-Prädikat-Inferenz, Syntaxprüfung regulärer Ausdrücke, sodass das Typsystem Codelogik präziser versteht
2024-11TypeScript 5.7Unterstützung für--target es2024, zuverlässigere Erkennung nicht initialisierter Variablen
2025-03TypeScript 5.8Verbesserte 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.

VergleichspunktTypeScriptJava / C#Go
TypsystemStrukturelle Typisierung (Duck-Typing)Nominale Typisierung (Vererbungsbeziehungen müssen explizit deklariert werden)Strukturelle Typisierung (implizite Interfaces)
Null-SicherheitAktivierungstrictNullChecksunterstützt es anschließendJava erfordert Annotationen oder Optional, C# 8+ unterstütztDurch Fehlerwerte und Nil-Prüfungen
GenerikaUnterstützt, Syntax ähnlich zu Java/C#Unterstützt, Java hat Einschränkungen durch Type ErasureGo 1.18+ unterstützt es, mit einfacherer Syntax
Kompilierte AusgabeJavaScript (läuft in JS-Umgebungen)Bytecode (läuft auf JVM / CLR)Nativer Maschinencode
Laufzeit-TypprüfungKeine (Typinformationen werden nach der Kompilierung gelöscht)Ja (Reflexionsmechanismus)Keine
LernkurveFreundlich für JS-Entwickler, kann schrittweise eingeführt werdenFür Anfänger steilerRelativ 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änkungBeschreibungWie man damit umgeht
Keine Typen zur LaufzeitTypinformationen werden nach der Kompilierung vollständig gelöscht, und auf Typen kann zur Laufzeit für Beurteilungen nicht vertraut werdenVerwenden Sie Bibliotheken wiezod、io-tswenn Laufzeitvalidierung erforderlich ist
KompilierungsschrittFügt im Vergleich zu reinem JS einen Kompilierungsschritt hinzu, was die Projektkomplexität erhöhtModerne Build-Tools (Vite, esbuild) kommen damit bereits gut zurecht
any-Typ-NotlösungÜbermäßige Verwendung vonanymacht die Typprüfung unwirksamAktivierennoImplicitAnyundstrictModus, kombiniert mit ESLint-Regeln
Hürde der Typ-GymnastikKomplexe bedingte Typen und Mapped Types sind nicht anfängerfreundlichDer meiste Business-Code erfordert keine fortgeschrittenen Typen; gehen Sie es Schritt für Schritt an
Unterstützung für Drittanbieter-BibliothekenEinige ältere Bibliotheken besitzen keine Typdefinitionen, sodass Sie die .d.ts selbst schreiben müssenPrüfe zuerst@types/*; falls tatsächlich nicht vorhanden, schreiben Sie die Deklarationsdatei manuell
Weitere Erweiterungen