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
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
// 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
// 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
// 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
// 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
// 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
// `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
// 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
Weitere ErweiterungenFortgeschritten:Die Kombination von Literaltypen mit dem diskriminierten Union-Muster ermöglicht mächtige Typsicherheit.