So verwenden Sie Aufzählungen in TypeScript

Eine Aufzählung oder ein Aufzählungstyp ist eine Datenstruktur, mit der Sie eine Reihe benannter Werte definieren können.

Aufzählungen bieten eine Möglichkeit, einen festen Satz von Werten als Konstanten darzustellen. Sie können dazu beitragen, Ihren Code ausdrucksvoller und selbstdokumentierender zu gestalten, indem sie bestimmten Werten aussagekräftige Namen geben. Hier erfahren Sie, wie Sie Enums in TypeScript verwenden können.

Erstellen einer Aufzählung

Aufzählungen stellen im Allgemeinen eine feste Anzahl von Optionen für einen bestimmten Wert dar. Beispielsweise könnte eine Aufzählung, die Primärfarben darstellt, feste Werte für Rot, Gelb und Blau haben.

Aufzählungen stellen Daten als eine Reihe von Schlüssel/Wert-Paaren dar, die als Aufzählungsmitglieder bezeichnet werden. Der Schlüssel muss immer eine Zeichenfolge sein. Der Wert – standardmäßig eine automatisch inkrementierende Zahl – kann jedoch numerisch, eine Zeichenfolge oder berechnet sein.

Sie können eine Enumeration in erstellen die TypeScript-Sprache Verwendung der Aufzählung Stichwort. Folgen Sie ihm mit dem Namen der Enumeration und zwei geschweiften Klammern ({}), die die Enum-Mitglieder enthält. Eine gängige JavaScript-Namenskonvention besagt, dass Enum-Namen mit einem Großbuchstaben beginnen sollten.

Aufzählung Richtung {
 Hoch,
 Runter,
 Links,
 Rechts
}

Dieses Beispiel enthält eine Enumeration namens Richtung. Die Enumeration verfügt über ein Mitglied, das jede Richtung darstellt: Oben, Unten, Links und Rechts.

Da dieser Code nicht für jeden Schlüssel einen Wert angibt, weist TypeScript automatisch Werte zu. Das erste Mitglied, Up, hat den Wert 0. Die verbleibenden Mitglieder haben jeweils einen Wert, der um 1 größer ist als der des vorherigen Mitglieds. Sie können dies explizit angeben, wenn Sie Schwierigkeiten haben, sich daran zu erinnern:

Aufzählung Richtung {
 Oben = 0,
 Unten = 1,
 Links = 2,
 Richtig = 3,
}

Oder Sie können explizit unterschiedliche Werte deklarieren und nicht deklarierte Werte wie zuvor weiter erhöhen:

Aufzählung Status {
 Aktiv = 9,
 Inaktiv, // 10
}

In diesem Beispiel hat das inaktive Mitglied einen Wert von 10. Dieses Verhalten gilt für Aufzählungen, die nur numerische Werte haben, nicht für Aufzählungen mit Zeichenfolgen oder heterogenen Mitgliedern.

Die verschiedenen Arten von Enum

Aufzählungen in TypeScript haben einen impliziten Typ, der auf dem Typ der Werte basiert, die ihre Mitglieder enthalten. Der gebräuchlichste Typ ist die numerische Aufzählung, deren Verhalten im vorherigen Abschnitt behandelt wird, es gibt jedoch zwei Variationen.

String-Aufzählungen

Eine String-Enumeration ist eine Enumeration, bei der alle ihre Mitglieder Strings sind. Im Gegensatz zu numerischen Aufzählungen, bei denen Werte automatisch zugewiesen werden, müssen Sie jedes Mitglied mit einer Zeichenfolge initialisieren:

Aufzählung Grundfarben {
 Rot = "ROT",
 Gelb = "GELB",
 Blau = "BLAU"
}

Obwohl String-Aufzählungen keine automatisch inkrementierenden Eigenschaften haben, sind sie möglicherweise sinnvoller, wenn Sie sie serialisieren. Ihre Werte sollten weiterhin beschreibend sein und keine Mitgliedsnamen enthalten, während eine Reihe numerischer Werte möglicherweise nicht selbstbeschreibend ist.

Heterogene Aufzählungen

Heterogene Aufzählungen sind Aufzählungen, die sowohl numerische als auch Zeichenfolgenelemente enthalten. Zum Beispiel:

Aufzählung Ergebnis {
 Erfolg = "ERFOLG",
 Fehler = 0
}

Heterogene Aufzählungen sind nützlich, wenn Sie Aufzählungsmitglieder haben, die basierend auf dem spezifischen Kontext oder der Bedeutung jedes Mitglieds unterschiedliche Werttypen erfordern. Allerdings ist die TypeScript-Dokumentation rät von der Verwendung heterogener Aufzählungen ab, da sie Komplexität mit sich bringen, die Ihren Code fehleranfälliger machen kann.

Berechnete und konstante Enum-Mitglieder

Jedes Enum-Mitglied hat einen Wert, der entweder konstant oder berechnet sein kann.

Konstante Enum-Mitglieder

Ein Enum-Mitglied ist konstant, wenn es eine der folgenden Bedingungen erfüllt.

1. Es ist das erste Mitglied der Enumeration und hat keinen Initialisierer.
2. Es gibt keinen Initialisierer und das vorangehende Enumerationselement war eine numerische Konstante.
3. Es wird mit einem konstanten Enum-Ausdruck initialisiert.

Laut der TypeScript-Dokumentation ist ein konstanter Enum-Ausdruck eine Teilmenge von TypeScript-Ausdrücken, die zur Kompilierungszeit vollständig ausgewertet werden kann. Zum Beispiel eine Zeichenfolge oder ein numerisches Literal.

Beispielsweise sind die Mitglieder der Aufzählungen im folgenden Codeblock alle konstant:

// FALL 1
Aufzählung Richtung {
 Hoch,
 Runter,
 Links,
 Rechts
}
// FALL 2
Aufzählung Wochentag {
 Montag = 1,
 Dienstag,
 Mittwoch,
 Donnerstag,
 Freitag
}
// FALL 3
Aufzählung Jahreszeit {
 Frühling = "FRÜHLING",
 Sommer = "SOMMER",
 Herbst = "HERBST",
 Winter = "WINTER"
}

Wenn Sie konstante Enum-Mitglieder in einfaches JavaScript transpilieren, verwendet der generierte Code deren Literalwerte. Dies kann sich positiv auf die Leistung auswirken und das Debuggen erleichtern.

Hier ist zum Beispiel die transpilierte Version der Season-Enumeration:

var Jahreszeit;
(Funktion (Jahreszeit) {
 Jahreszeit["Frühling"] = "FRÜHLING";
 Jahreszeit["Sommer"] = "SOMMER";
 Jahreszeit["Herbst"] = "HERBST";
 Jahreszeit["Winter"] = "WINTER";
})(Staffel || (Staffel = {}));

Berechnete Enum-Mitglieder

Sie können berechnete Aufzählungsmitglieder verwenden, um Aufzählungsmitgliedern Werte basierend auf Ausdrücken oder anderen dynamischen Berechnungen zuzuweisen. Zum Beispiel:

Aufzählung Größe {
 Klein = 1,
 Mittel = berechneGröße(12),
 Groß = berechneGröße(5)
}
FunktionberechneGröße(Wert: Nummer): Nummer{
zurückkehren Wert * 5;
}
Konsole.log (Größe. Groß)

Der Größe enum hat drei Mitglieder: Klein, Mittel, Und Groß. Es weist dem Small-Mitglied explizit den Wert 1 zu. Der Mittel Und Groß Mitglieder verwenden eine Funktion berechneGröße um ihre Werte zur Laufzeit zu berechnen.

Bei der Arbeit mit berechneten Enum-Mitgliedern ist zu beachten, dass die Werte erst zur Laufzeit bekannt sind. Dies kann zu mehr Komplexität und Potenzial führen Laufzeitfehler im Vergleich zu Enum-Mitgliedern mit konstanten Werten.

Zum Beispiel:

var Größe;
(Funktion (Größe) {
 Größe[Größe["Klein"] = 1] = "Klein";
 Größe[Größe["Mittel"] = berechneGröße(12)] = "Mittel";
 Größe[Größe["Groß"] = berechneGröße(5)] = "Groß";
})(Größe || (Größe = {}));
Konsole.Protokoll(Größe.Groß)

Der obige Codeblock ist die transpilierte Version von Größe Aufzählung. Beachten Sie, dass TypeScript die Rückgabewerte von berechneSize() nicht in den JavaScript-Code einbezieht. Stattdessen wird der ursprüngliche Funktionsaufruf einbezogen, sodass JavaScript die Werte zur Laufzeit ermittelt.

Auf Enum-Werte zugreifen

Sie können mithilfe der Objektpunktnotation auf die Werte von Enum-Mitgliedern zugreifen.

Zum Beispiel:

Aufzählung Richtung {
 Oben = 0,
 Unten = 1,
 Links = 2,
 Richtig = 3,
}
Konsole.log (Richtung. Links) // 2

Numerische Aufzählungen umgekehrt zuordnen

Die umgekehrte Zuordnung in numerischen Aufzählungen bezieht sich auf die Möglichkeit, den entsprechenden Namen des Aufzählungsmitglieds aus seinem Wert abzurufen. Dies kann besonders nützlich sein, wenn Sie mit numerischen Werten arbeiten, die Sie möglicherweise dekodieren müssen.

Standardmäßig werden Enum-Werte in TypeScript vorwärts zugeordnet, was bedeutet, dass Sie nur auf den mit einem Namen verknüpften Wert zugreifen können. Sie können jedoch manuell eine umgekehrte Zuordnung durchführen, um das Enumerationsmitglied basierend auf seinem Wert abzurufen.

Zum Beispiel:

Aufzählung Richtung {
 Oben = 1,
 Runter,
 Links,
 Rechts
}
FunktiongetDirectionName(Richtungswert: Nummer): Zeichenfolge{
// Reverse-Mapping
const DirectionName = Direction[directionValue];
zurückkehren Richtungsname;
}
Konsole.log (getDirectionName(1)); // "Hoch"
Konsole.log (getDirectionName(3)); // "Links"

Das getDirectionName Die Funktion führt eine umgekehrte Zuordnung durch, indem sie auf den Namen des Enum-Mitglieds zugreift und seinen Wert als Index verwendet. Die Funktion dauert a Richtungswert als Argument und ruft den entsprechenden Enum-Mitgliedsnamen mit ab Richtung[Richtungswert].

Die umgekehrte Zuordnung kann in Szenarien nützlich sein, in denen Sie einen numerischen Wert haben und den entsprechenden Namen des Enum-Mitglieds ermitteln müssen. Es bietet eine bequeme Möglichkeit, mit Aufzählungen sowohl in Vorwärts- als auch in Rückwärtsrichtung zu arbeiten.

Es gibt viele Anwendungen von Enums

Sie können Aufzählungen in verschiedenen Szenarien verwenden, z. B. zur Verarbeitung von Switch-Anweisungen, zum Definieren von Funktionsparametern, zum Zuordnen von Daten und zum Darstellen von Auswahlmöglichkeiten oder Einstellungen.

Unabhängig davon, ob Sie einen endlichen Satz von Optionen darstellen oder komplexe Zustandsübergänge verwalten müssen, sind Aufzählungen in TypeScript ein wertvolles Werkzeug, um die Klarheit und Struktur Ihres Codes zu verbessern.