TypeScript-Merkmale

Im Vergleich zu JavaScript fügt TypeScript viele wichtige Merkmale hinzu, insbesondere Verbesserungen rund um das Typsystem und die Codestruktur.

Einige wichtige Merkmale von TypeScript:

  • Statische Typprüfung: TypeScript prüft zur Kompilierzeit, ob Codetypen übereinstimmen, und fängt viele potenzielle Fehler ab. Sogar einfache Fehler (wie Tippfehler oder Typinkonsistenzen) können schon beim Schreiben von Code erkannt werden.

  • Typinferenz: TypeScript kann Variablentypen automatisch ableiten. Wenn Sie beispielsweise eine Variable deklarieren und ihr einen Wert zuweisen, leitet TypeScript den Typ der Variable anhand der Zuweisung ab, sodass Sie nicht jedes Mal explizit Typen deklarieren müssen.

  • Interfaces und Typdefinitionen: TypeScript bietet dasinterfaceundtypeSchlüsselwort, mit dem Sie komplexe Datenstrukturen definieren können. Dies ist sehr wichtig für die Zusammenarbeit am Code und die Dateninteraktion zwischen verschiedenen Teilen eines Projekts.

  • Klassen- und Modulunterstützung: TypeScript unterstützt das Klassenkonzept aus der objektorientierten Programmierung, fügt Konstruktoren, Vererbung, Zugriffsmodifikatoren (wiepublic、private、protected) hinzu und unterstützt die ES-Modulspezifikation.

  • Werkzeug- und Editor-Unterstützung: TypeScript bietet eine hervorragende Editor-Unterstützung, insbesondere in Verbindung mit Visual Studio Code, mit IntelliSense, automatischer Vervollständigung, Refactoring und anderen Werkzeugen, was die Entwicklung effizienter macht.

  • Kompatibel mit JavaScript: TypeScript ist eine Obermenge von JavaScript, was bedeutet, dass jeder gültige JavaScript-Code auch gültiger TypeScript-Code ist. Dadurch können JavaScript-Projekte schrittweise zu TypeScript migrieren, ohne vollständig neu geschrieben zu werden.

Im Folgenden sind die wichtigsten Funktionen aufgeführt, die TypeScript hinzufügt:

1. Statische Typen

Die größte Funktion von TypeScript ist die Hinzufügung eines statischen Typsystems. In TypeScript können Entwickler Typen für Variablen, Parameter und Rückgabewerte explizit deklarieren, wodurch viele potenzielle Typfehler zur Kompilierungszeit erkannt werden können. Zu den gängigen Typen gehörennumber、string、boolean、array、tuple、enumusw., und benutzerdefinierte Typen werden ebenfalls unterstützt.

let name: string = "Alice";
let age: number = 25;

2. Typinferenz

TypeScript kann Variablentypen automatisch ableiten. Selbst ohne explizite Typdeklaration leitet TypeScript Typen anhand des zugewiesenen Werts ab, wodurch in den meisten Fällen weniger Typannotationen erforderlich sind.

let name = "Alice"; // 推断为 string

3. Interfaces

TypeScript bietet Schnittstellen, mit denen komplexe Objektstrukturen definiert werden können. Schnittstellen können Eigenschaften und Methoden definieren und können mit demimplementsSchlüsselwort implementiert oder durchextendserweitert werden, um die Definition komplexer Datentypen zu erleichtern.

interface Person {
  name: string;
  age: number;
  greet(): void;
}

class Student implements Person {
  constructor(public name: string, public age: number) {}

  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

4. Typaliase

Typ-Aliase (type) können kurze Aliase für komplexe Typen definieren und so die Wiederverwendung von Code erleichtern.

type StringOrNumber = string | number;
let value: StringOrNumber = 42;

5. Aufzählungen

TypeScript führt denenumTyp ein, der verwendet wird, um eine Menge benannter Konstanten zu definieren, was die Lesbarkeit des Codes verbessert. Enums haben keine direkte Entsprechung in JavaScript.

enum Direction {
  Up,
  Down,
  Left,
  Right,
}
let dir: Direction = Direction.Up;

6. Tupel

Tupel ermöglichen die Definition von Arrays mit einer festen Anzahl und festen Typen von Elementen. Sie eignen sich für Szenarien, die feste Datenstrukturen erfordern, wie Koordinaten oder RGB-Farbwerte.

let point: [number, number] = [10, 20];

7. Zugriffsmodifikatoren

TypeScript bietet diepublic、privateundprotectedModifikatoren in Klassen, die die Kontrolle über die Sichtbarkeit von Eigenschaften oder Methoden ermöglichen und eine bessere Kapselung unterstützen.

class Person {
  private name: string;
  protected age: number;
  public constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

8. Abstrakte Klassen

TypeScript unterstützt abstrakte Klassen. Abstrakte Klassen können nicht direkt instanziiert werden und müssen von Unterklassen implementiert werden. Abstrakte Klassen eignen sich zur Definition von Klassenhierarchien mit gemeinsamem Verhalten und abstrakten Methoden.

abstract class Animal {
  abstract makeSound(): void;
}

class Dog extends Animal {
  makeSound() {
    console.log("Woof!");
  }
}

9. Generika

TypeScript unterstützt Generics, wodurch parametrisierte Typen in Klassen, Schnittstellen und Funktionen möglich sind, sodass Code sich an unterschiedliche Typanforderungen anpassen kann und dabei Typsicherheit gewahrt bleibt.

function identity<T>(value: T): T {
  return value;
}

let num = identity<number>(42);

10. Module und Namespaces

TypeScript bietet ein auf ES6 basierendes Modulsystem, dasimportundexportzum Importieren und Exportieren von Modulen verwendet wird. Darüber hinaus unterstützt TypeScript Namespaces zur Organisation von Code und zur Vermeidung von Namenskonflikten.

// math.ts
export function add(a: number, b: number): number {
  return a + b;
}

// main.ts
import { add } from "./math";
console.log(add(2, 3));

11. Typwächter

TypeScript bietet Typwächter, mit denen Variablentypen im Code geprüft werden können und die dem Compiler helfen, spezifischere Typen abzuleiten. Dies ist besonders wichtig für Union-Typen.

function printId(id: string | number) {
  if (typeof id === "string") {
    console.log(id.toUpperCase());
  } else {
    console.log(id.toFixed(2));
  }
}

12. Optionale Verkettung und Nullish-Coalescing-Operatoren

TypeScript fügt JavaScripts optionale Verkettung (?.) und Nullish-Coalescing-Operator (??), was die Handhabung potenziellnulloderundefinedauftretender Werte im Code vereinfacht.

let user = { name: "Alice", address: { city: "Wonderland" } };
console.log(user?.address?.city); // 如果 address 存在则输出 city,否则返回 undefined

let value = null;
console.log(value ?? "default"); // 如果 value 为 null 或 undefined,则返回 "default"

13. Typkompatibilität und Utility-Typen

TypeScript bietet einige Utility-Typen, wie z. B.Partial、Pick、Readonly、Recordusw. Diese Typen können dabei helfen, neue Typen zu generieren und Typdefinitionen zu vereinfachen.

interface Todo {
  title: string;
  description: string;
}

let partialTodo: Partial<Todo> = { title: "Learn TypeScript" }; // 可选属性

14. Kompilierzeit-Fehlerprüfung

Die Kompilierzeit-Fehlerprüfung von TypeScript kann Fehler erkennen, die in JavaScript schwer zu entdecken sind, wie Tippfehler und Typabweichungen, und so die Codequalität verbessern.

15. Unterstützung für neue ES-Funktionen

TypeScript unterstützt einige ES-Funktionen, die in allen Umgebungen noch nicht weit verbreitet sind, wie Decorators und Async-Iteratoren, und kann sie in kompatible JavaScript-Versionen kompilieren.

Durch diese Funktionen bietet TypeScript sicherere und strukturiertere Programmiermöglichkeiten, die besonders bei großen Projekten und der Zusammenarbeit mehrerer Personen von Vorteil sind.

Weitere Erweiterungen