TypeScript-Typalias

Ein Typalias wird verwendet, um einen Alias für einen vorhandenen Typ zu erstellen, wodurch der Code übersichtlicher und leichter lesbar wird.

Mit Typaliasen können Sie einen kurzen Namen für komplexe Typen definieren, was die Wartbarkeit des Codes verbessert.


SVG-Diagramm: Typalias Background Title How type aliases work Original type Original complex type type User = { name: string; age: number; email: string; } Arrow Definition type alias type alias type UserID = User; // or type ID = string | number; Arrow Usage Usage Use in code var id: UserID; var uid: ID; Lower part: application scenarios Application scenarios for type aliases Scenario 1 Basic type alias Scenario 2 Union type alias Scenario 3 Function type alias Scenario 4 Generic type alias Arrow marker

Warum brauchen wir Typaliase

Wenn derselbe komplexe Typ im Code viele Male verwendet wird, wird es umständlich, jedes Mal den vollständigen Typ zu schreiben.

Typaliase können einen prägnanten Namen für komplexe Typen definieren, wodurch der Code lesbarer und wartbarer wird.

Typaliase sind besonders nützlich, wenn man mit komplexen Typen wie Union-Typen, Funktionstypen und Tupeln arbeitet.

Konzepterklärung:Verwendung von Typaliasentypemit dem Schlüsselwort `type` definiert; es gibt einem vorhandenen Typ einfach einen neuen Namen und erstellt keinen neuen Typ.


Grundlegende Verwendung

Verwende das Schlüsselwort `type`, um einen Alias für einen Typ zu definieren.

Beispiel

// Typalias: einen Alias für einen Union-Typ definieren
// ID kann ein String oder eine Zahl sein
type ID = string | number;

// Typalias: einen Alias für einen Objekttyp definieren
// Point repräsentiert einen Koordinatenpunkt
type Point = { x: number; y: number };

// Verwenden Sie den Typalias
var userId: ID = "123";
var productId: ID = 456;

// Verwende den Point-Typalias
var point: Point = { x: 10, y: 20 };

console.log("Benutzer-ID: " + userId);
console.log("Produkt-ID: " + productId);
console.log("Koordinaten: " + JSON.stringify(point));

Ausgabe:

用户ID: 123
产品ID: 456
坐标: {"x":10,"y":20}

Erklärung:Ein Typalias gibt einem Typ einfach einen neuen Namen; er erzeugt nach der Kompilierung keinen tatsächlichen Code und wird während der Entwicklung ausschließlich zur Typprüfung verwendet.


Interface vs. Typalias

Typaliase und Interfaces sind sehr ähnlich; beide können verwendet werden, um Objekttypen zu definieren, aber es gibt einige subtile Unterschiede.

Beispiel

// Verwende einen Typalias, um einen Objekttyp zu definieren
// type kann jeden Typ definieren, nicht nur Objekte
type PersonType = {
    name: string;
    age: number;
};

// Verwende ein Interface, um einen Objekttyp zu definieren
// Interfaces unterstützen Deklarationszusammenführung und können von Klassen implementiert werden
interface PersonInterface {
    name: string;
    age: number;
}

// Beide können verwendet werden, um Variablentypen zu deklarieren
var person1: PersonType = { name: "Alice", age: 25 };
var person2: PersonInterface = { name: "Bob", age: 30 };

console.log("PersonType: " + JSON.stringify(person1));
console.log("PersonInterface: " + JSON.stringify(person2));

Unterschiede:type kann jeden Typ definieren (Union-Typen, Tupel, Funktionstypen usw.), während interfaces hauptsächlich für Objekttypen verwendet werden. Interfaces unterstützen Deklarationszusammenführung, aber type nicht.


Typ-Aliase und Union-Typen

Typ-Aliase eignen sich perfekt zum Definieren von Union-Typen und machen den Code klarer.

Beispiel

// Union-Typ-Alias: mögliche Werte für einen Status definieren
// Status kann nur einer dieser drei String-Literale sein
type Status = "pending" | "success" | "error";

// Union-Typ-Alias: mehrere mögliche Rückgabetypen definieren
// Result kann ein String, eine Zahl oder ein Boolean sein
type Result = string | number | boolean;

// Den Union-Typ-Alias verwenden
function getStatus(status: Status): void {
    console.log("Status: " + status);
}

getStatus("success");
getStatus("error");

// Den Result-Typ verwenden
var result: Result = "hello";
result = 42;
console.log("Ergebnis: " + result);

Ausgabe:

Status: success
Status: error
结果: 42

Anwendungsszenarien:Union-Typ-Aliase werden häufig verwendet, um Statuscodes, Fehlertypen, API-Rückgabewerte und ähnliche Szenarien zu definieren.


Typaliase und Tupel

Typaliase können auch verwendet werden, um Tupeltypen zu definieren.

Beispiel

// Tupel-Typalias: Koordinaten definieren
// Coordinate ist ein Tupel, das zwei Zahlen enthält
type Coordinate = [number, number];

// Tupel-Typalias: Name und Alter definieren
// NameAge ist ein Tupel aus einem String und einer Zahl
type NameAge = [string, number];

// Tupel-Typalias verwenden
var coord: Coordinate = [10, 20];
var person: NameAge = ["Alice", 25];

console.log("Koordinaten: " + coord);
console.log("Info: " + person[0] + ", " + person[1]);

Erklärung:Tupel-Typ-Aliase machen die Verwendung von Tupeln klarer und vermeiden, dass der vollständige Tupeltyp jedes Mal ausgeschrieben werden muss.


Typaliase und Funktionen

Typaliase können Funktions-Typdeklarationen vereinfachen.

Beispiel

// Funktionstyp-Alias: einen Callback-Funktionstyp definieren
// Callback nimmt einen string-Parameter entgegen und gibt void zurück
type Callback = (result: string) => void;

// Funktionstyp-Alias: einen Funktionstyp für eine mathematische Operation definieren
// MathOperation nimmt zwei number-Parameter entgegen und gibt einen number-Wert zurück
type MathOperation = (a: number, b: number) => number;

// Den Funktionstyp-Alias verwenden
var add: MathOperation = function(a, b) { return a + b; };
var multiply: MathOperation = function(a, b) { return a * b; };

console.log("Addition: " + add(2, 3));
console.log("Multiplikation: " + multiply(4, 5));

Ausgabe:

加法: 5
乘法: 20

Vorteile:Funktionstyp-Aliase machen Funktionstypdeklarationen prägnanter, insbesondere wenn dieselbe Funktionssignatur mehrmals benötigt wird.


Typ-Aliase und Generics

Typ-Aliase können mit Generics verwendet werden, um wiederverwendbare Typdefinitionen zu erstellen.

Beispiel

// Generischer Typ-Alias: einen Ergebnistyp definieren
// Result<T> ist ein generischer Typ; T ist der Datentyp bei Erfolg
type Result<T> = { success: boolean; data?: T; error?: string };

// Generischer Typ-Alias: einen Schlüssel-Wert-Paar-Typ definieren
// Pair<K, V> hat zwei Typparameter
type Pair<K, V> = { key: K; value: V };

// Den generischen Typ-Alias verwenden
var result: Result<string> = { success: true, data: "Hello" };
var pair: Pair<string, number> = { key: "age", value: 25 };

console.log("Ergebnis: " + JSON.stringify(result));
console.log("Schlüssel-Wert-Paar: " + JSON.stringify(pair));

Ausgabe:

结果: {"success":true,"data":"Hello"}
键值对: {"key":"age","value":25}

Vorteile von Generics:Generische Typ-Aliase können sich an verschiedene Datentypen anpassen und dadurch die Wiederverwendbarkeit des Codes verbessern.


Typ-Aliase und zugeordnete Typen

Typ-Aliase können mit zugeordneten Typen kombiniert werden, um leistungsstarke Typentransformationen zu erstellen.

Beispiel

// Zugeordneter Typ: alle Eigenschaften schreibgeschützt machen
// Readonly<T> iteriert über alle Eigenschaften von T und fügt readonly hinzu
type Readonly<T> = { readonly [P in keyof T]: T[P] };

// Mapped Type: Alle Eigenschaften optional machen
// Partial<T> iteriert über alle Eigenschaften von T und fügt ? hinzu
type Partial<T> = { [P in keyof T]?: T[P] };

// Ein User-Interface definieren
interface User {
    name: string;
    age: number;
}

// Verwende Aliase für zugeordnete Typen
var readonlyUser: Readonly<User> = { name: "Alice", age: 25 };
// readonlyUser.name = "Bob"; // Fehler: readonly-Eigenschaft kann nicht geändert werden

var partialUser: Partial<User> = { name: "Bob" };

console.log("Nur-Lese-Benutzer: " + JSON.stringify(readonlyUser));
console.log("Partieller Benutzer: " + JSON.stringify(partialUser));

Tipp:Mapped Types sind eine sehr mächtige Funktion von TypeScript, mit der du neue Typvarianten basierend auf vorhandenen Typen erstellen kannst.


Hinweise

  • Kann nicht neu definiert werden:Derselbe Typalias kann nicht neu definiert werden (Interfaces können durch Declaration Merging zusammengeführt werden)
  • Nur zur Kompilierzeit gültig:Typaliase erzeugen nach der Kompilierung keinen Code
  • Lesbarkeit zuerst:Verwende Typaliase nicht übermäßig; prägnanter und klarer Code ist besser

Best Practices:Verwende Typaliase, wenn ein Typ wiederverwendet werden muss oder wenn der Typname zu lang ist. Für einfache Objekttypen kannst du type oder interface basierend auf den Vorlieben deines Teams wählen.


Zusammenfassung

Typaliase sind eine sehr nützliche Funktion in TypeScript.

  • Grundlegende Verwendung:Verwende das Schlüsselwort `type`, um einen Alias für komplexe Typen zu definieren
  • Union-Typen:Definiere Kombinationen mehrerer möglicher Typen
  • Funktionstypen:Vereinfache Funktionstypdeklarationen
  • Generics:Wiederverwendbare generische Typen erstellen
  • Mapped Types:Neue Typen auf Basis vorhandener Typen erstellen

Empfehlung:Die angemessene Verwendung von Typaliasen kann den Code klarer machen, aber übertreiben Sie es nicht. Code prägnant und lesbar zu halten, ist das Wichtigste.

Weitere Erweiterungen