TypeScript Literal-Typen

Literal Types sind ein Feature in TypeScript, das spezifische Werte statt generischer Typen repräsentiert.

Es ermöglicht uns, den Variablentyp auf spezifische Werte zu beschränken, statt auf breite Typen wie string, number usw.

Dies bietet eine präzisere Typkontrolle und macht den Code typsicherer.


SVG-Diagramm: Literal-Typen Background Title Literal Types Example General Type General Type var direction: string; Can assign any string "up", "down", "abc"... Arrow Literal Type Literal Type var direction: "up" | "down" | "left" | "right" Can only assign one of these four values Arrow Result Type Safety When assigning an incorrect value Compilation Error! direction = "upup" Lower section: Kinds of Literal Types Kinds of Literal Types String literal String literal "up" | "down" | "left" Restrict to specific strings Number literal Number literal 1 | 2 | 3 | 100 | 200 Restrict to specific numbers Boolean literal Boolean literal true | false true or false Template literal Template literal `on${string}` Dynamically generated Arrow marker

Warum man Literal-Typen braucht

In TypeScript sind Standardtypen wie string und number zu allgemein.

Manchmal benötigen wir eine genauere Typkontrolle. Zum Beispiel kann eine Variable nur wenige bestimmte Werte annehmen.

Literal-Typen sind genau dafür gedacht, solche Probleme zu lösen.

Konzepterklärung:Literal-Typen sind konkrete Werte allgemeiner Typen (string, number). Zum Beispiel"up"JastringEin Untertyp, und die einzigen Werte, die ihm zugewiesen werden können, sind bestimmte Strings.


String-Literal-Typen

String-Literal-Typen beschränken die Variable auf bestimmte String-Werte.

Dies ist nützlich, wenn Sie eine Variable darauf beschränken müssen, nur bestimmte feste Werte anzunehmen.

Beispiel

// Einen String-Literal-Typ definieren
// direction kann nur einen von vier bestimmten Werten annehmen.
var direction: "up" | "down" | "left" | "right";

// Korrekt: einen Wert aus dem Literaltyp zuweisen
direction = "up";

// Fehler: einen Wert zuweisen, der nicht in der Liste ist
// direction = "upup"; // Kompilierungsfehler!

console.log("Richtung: " + direction);

// Verwenden Sie einen Typalias, um einen wiederverwendbaren Literaltyp zu erstellen
// Definieren Sie einen Status-Typ: kann nur einer von drei festen Werten sein
type Status = "pending" | "active" | "completed";

// Verwenden Sie den Typalias
var currentStatus: Status = "active";
console.log("Status: " + currentStatus);

Ausgabe:

方向: up
Status: active

Anwendungsszenarien:String-Literale werden häufig verwendet, um Enum-Werte, Statuscodes, Konfigurationsoptionen und andere Szenarien zu definieren, die auf bestimmte Werte beschränkt werden müssen.


Zahlen-Literal-Typen

Zahlen-Literal-Typen beschränken die Variable auf bestimmte numerische Werte.

Dies ist nützlich, wenn Sie bestimmte numerische Werte verwenden müssen (z. B. Statuscodes, Fehlercodes).

Beispiel

// Definieren Sie einen Zahlen-Literal-Typ
// code kann nur einen von drei bestimmten Werten annehmen
var code: 200 | 404 | 500;

// Korrekt: 200 zuweisen
code = 200;

// Fehler: einen Wert zuweisen, der nicht in der Liste ist
// code = 301; // Kompilierungsfehler!

console.log("Status code: " + code);

// Verwenden Sie Zahlen-Literale, um ein Enum zu simulieren
// Definieren Sie die Wochentage
type Weekday = 1 | 2 | 3 | 4 | 5 | 6 | 7;

// Es können nur Zahlen zwischen 1 und 7 zugewiesen werden
var today: Weekday = 1;
console.log("Heute ist Wochentag: " + today);

Erklärung:Zahlenliterale können als Ersatz für einfache Enums verwendet werden, insbesondere wenn nur wenige feste numerische Werte benötigt werden.


Boolesche Literaltypen

Boolesche Literaltypen beschränken die Variable auf true oder false.

Tatsächlich ist der boolean-Typ in TypeScript ein Alias für `true | false`.

Beispiel

// Einen booleschen Literaltyp definieren
// isActive kann nur true oder false sein
var isActive: true | false;

// true zuweisen
isActive = true;

// Tatsächlich ist boolean ein Union-Typ aus true | false
// Diese beiden Schreibweisen sind also äquivalent
var flag: boolean = true;

console.log("Ist aktiv: " + isActive);

Hinweis:Obwohl boolean selbst ausreicht, können Sie true oder false als Typ verwenden, wenn Sie klar zwischen den Typen true und false unterscheiden müssen.


Objekt-Literal-Typen

Objekt-Literal-Typen können die Struktur eines Objekts definieren und den readonly-Modifikator verwenden, um Eigenschaften schreibgeschützt zu machen.

Dies ist sehr nützlich, wenn Sie unveränderliche Objekte erstellen müssen.

Beispiel

// Einen Objekt-Literal-Typ definieren
// Struktur und Eigenschaftstypen des Objekts angeben
type Point = {
    // Die x-Koordinate des Punktes
    x: number;
    // Die y-Koordinate des Punktes
    y: number;
};

// Verwende den Objektliteral-Typ
var p: Point = { x: 10, y: 20 };
console.log("Punkt: " + JSON.stringify(p));

// Einen schreibgeschützten Objekttyp definieren
// Verwende den readonly-Modifizierer, um Eigenschaften schreibgeschützt zu machen
type ReadonlyPoint = {
    // Schreibgeschützte x-Koordinate
    readonly x: number;
    // Schreibgeschützte y-Koordinate
    readonly y: number;
};

// Verwende den schreibgeschützten Objekttyp
var rp: ReadonlyPoint = { x: 1, y: 2 };

// Der Versuch, eine schreibgeschützte Eigenschaft zu ändern, führt zu einem Fehler
// rp.x = 3; // Kompilierungsfehler: Schreibgeschützte Eigenschaft kann nicht geändert werden

console.log("Schreibgeschützter Punkt: " + JSON.stringify(rp));

Ausgabe:

点: {"x":10,"y":20}
只读点: {"x":1,"y":2}

Anwendungsszenarien:Schreibgeschützte Objekte werden häufig verwendet, um Konfigurationsobjekte, konstante Objekte und andere Daten zu definieren, die nicht geändert werden sollten.


Literal-Typen und Typinferenz

TypeScript leitet Literaltypen automatisch basierend darauf ab, wie Variablen deklariert werden.

Mit const deklarierte Variablen werden als spezifische Literaltypen und nicht als allgemeine Typen abgeleitet.

Beispiel

// Mit var deklarieren und zuweisen
// TypeScript leitet einen allgemeinen Typ ab
var name = "Alice";    // Typ: string (weil var neu zugewiesen werden kann)
var age = 25;          // Typ: number
var enabled = true;    // Typ: boolean

console.log("Name: " + name + ", Alter: " + age + ", Aktiviert: " + enabled);

// Verwende as const, um ein tief schreibgeschütztes Literal zu erstellen
// Das Array wird zu einem schreibgeschützten Tupel, und die Werte sind Literaltypen
var colors = ["red", "green", "blue"] as const;

// Der Typ von colors wird zu:
// readonly ["red", "green", "blue"]

// Auf Array-Elemente zugreifen
console.log("Farben: " + colors[0]);

// Ein Änderungsversuch verursacht einen Fehler
// colors

Erklärung:as constEs wird den Typ als den spezifischsten Literaltyp ableiten und den readonly-Modifikator hinzufügen.


Template-Literal-Typen

Template-Literal-Typen verwenden die JavaScript-Template-String-Syntax, um neue Typen zu erstellen.

Es ermöglicht uns, String-Typen dynamisch zu generieren.

Beispiel

// Template-Literal-Typen verwenden, um Ereignisnamen zu definieren
// `on${string}` repräsentiert jede Zeichenkette, die mit "on" beginnt
type EventName = `on${string}`;

// Template-Literal-Typen verwenden, um Handler-Namen zu definieren
// Capitalize wandelt den ersten Buchstaben einer Zeichenkette in einen Großbuchstaben um
type Handler = `handle${Capitalize<string>}`;

// Den Template-Literal-Typ verwenden
var event: EventName = "onClick";
var handler: Handler = "handleSubmit";

console.log("Event: " + event);
console.log("Handler: " + handler);

// Fehler: entspricht nicht dem Template-Format
// var e: EventName = "click"; // Kompilierungsfehler: beginnt nicht mit "on"

Run result:

事件: onClick
处理器: handleSubmit

Eingebaute Utility-Typen:Template-Literal-Typen können mit eingebauten Utility-Typen wie Uppercase, Lowercase, Capitalize, Uncapitalize usw. verwendet werden.


Praxisnahe Anwendung: Redux Action

Literal-Typen haben vielfältige Anwendungen in der praktischen Entwicklung.

Das Folgende zeigt, wie man Literal-Typen verwendet, um Redux-artige Actions zu implementieren.

Beispiel

// Redux-artige Action-Typen definieren
// Union-Typen verwenden, um verschiedene Arten von Actions zu definieren
type Action =
    // Aktion vom Typ increment mit einer numerischen Nutzlast
    | { type: "increment"; payload: number }
    // Aktion vom Typ decrement mit einer numerischen Nutzlast
    | { type: "decrement"; payload: number }
    // Aktion vom Typ reset ohne Nutzlast
    | { type: "reset" };

// Reducer-Funktion, die action verwendet
function reducer(action: Action): void {
    // TypeScript leitet den spezifischen Typ von action automatisch anhand des Werts von action.type ab
    switch (action.type) {
        case "increment":
            // In diesem Zweig wird action als { type: "increment"; payload: number } abgeleitet
            console.log("Increment: " + action.payload);
            break;
        case "decrement":
            // In diesem Zweig wird action als { type: "decrement"; payload: number } abgeleitet
            console.log("Decrement: " + action.payload);
            break;
        case "reset":
            // In diesem Zweig wird action als { type: "reset" } abgeleitet
            console.log("Reset");
            break;
    }
}

// Verschiedene Arten von Actions dispatchen
reducer({ type: "increment", payload: 5 });
reducer({ type: "reset" });

Run result:

增加: 5
重置

Diskriminierte Union:Dieses Muster wird als "diskriminierte Union" bezeichnet und ist die bewährte Vorgehensweise für den Umgang mit mehreren verwandten Typen in TypeScript.


Hinweise

  • Type Narrowing:Bei der Verwendung von switch- oder if-Prüfungen verengt TypeScript automatisch Literaltypen
  • Typaliase:Es wird empfohlen, Typaliase zu verwenden, um Aliase für häufig verwendete Literaltypen zu erstellen.
  • const-Inferenz:Mit const deklarierte Variablen werden automatisch als Literaltypen abgeleitet
  • as const:Verwende as const, wenn tiefes readonly benötigt wird

Best Practices:Wenn Sie eine Variable auf nur bestimmte Werte beschränken müssen, bevorzugen Sie Literaltypen gegenüber Enums.


Zusammenfassung

Literaltypen sind ein wichtiges Feature von TypeScript, um präzise Typkontrolle zu erreichen.

  • String-Literale:Auf bestimmte Strings beschränkt, wie z. B."up" | "down"
  • Numerische Literale:Auf bestimmte Zahlen beschränkt, wie z. B.1 | 2 | 3
  • Boolean-Literale:Auf true oder false beschränkt
  • Objektliterale:Objektstruktur definieren, readonly kann verwendet werden
  • as const:Erstelle tiefe readonly-Literaltypen
  • Template-Literale:Typen dynamisch mithilfe von Template-Strings generieren

Fortgeschritten:Die Kombination von Literaltypen mit dem diskriminierten Union-Muster ermöglicht mächtige Typsicherheit.

Weitere Erweiterungen