TypeScript - Enums: Ein Anfängerguide

Hallo, zukünftige Programmierer! Heute tauchen wir in die wundervolle Welt der TypeScript Enums ein. Keine Sorge, wenn ihr noch nie zuvor programmiert habt – ich werde dein freundlicher Guide auf dieser Reise sein, genau wie ich es für unzählige Schüler in meinen Jahren als Lehrer war. Also, los geht's!

Was sind Enums?

Bevor wir uns mit den verschiedenen Arten von Enums beschäftigen, lassen wir uns erstmal klar machen, was sie sind. Stell dir vor, du organisiert deinen Schrank. Du könntest verschiedene Kategorien für deine Kleidung haben: Shirts, Hosen, Schuhe usw. Enums in TypeScript sind wie diese Kategorien – sie helfen uns, verwandte Werte zusammenzufassen und ihnen bedeutungsvolle Namen zu geben.

Numerische Enums

Numerische Enums sind die am häufigsten verwendete Art von Enums in TypeScript. Sie sind wie das Zuweisen von Zahlen zu deinen Lieblings-Superhelden.

enum Superheroes {
Superman,
Batman,
WonderWoman,
Flash
}

console.log(Superheroes.Superman);  // Ausgabe: 0
console.log(Superheroes.Batman);    // Ausgabe: 1
console.log(Superheroes.WonderWoman);  // Ausgabe: 2
console.log(Superheroes.Flash);     // Ausgabe: 3

In diesem Beispiel weist TypeScript automatisch Zahlen beginnend mit 0 zu. Superman erhält 0, Batman erhält 1 und so weiter. Es ist, als ob sie sich für ein Gruppenfoto anstellen und wir ihnen basierend auf ihrer Position Zahlen geben!

Was aber, wenn wir mit einer anderen Zahl beginnen möchten? Kein Problem! Das können wir auch:

enum Villains {
Joker = 1,
LexLuthor,
Cheetah,
ReverseFlash
}

console.log(Villains.Joker);        // Ausgabe: 1
console.log(Villains.LexLuthor);    // Ausgabe: 2
console.log(Villains.Cheetah);      // Ausgabe: 3
console.log(Villains.ReverseFlash); // Ausgabe: 4

Hier haben wir TypeScript gesagt, dass es mit der Zählung von 1 für Joker beginnen soll, und es hat automatisch fortgesetzt.

String-Enums

Nun, sagen wir, du bist kein Fan von Zahlen und bevorzugst Wörter. Dann sind String-Enums genau das Richtige für dich. Sie sind wie das Geben von Nicknames deinen Haustieren!

enum PetNames {
Dog = "BUDDY",
Cat = "WHISKERS",
Fish = "BUBBLES",
Bird = "TWEETY"
}

console.log(PetNames.Dog);   // Ausgabe: "BUDDY"
console.log(PetNames.Cat);   // Ausgabe: "WHISKERS"
console.log(PetNames.Fish);  // Ausgabe: "BUBBLES"
console.log(PetNames.Bird);  // Ausgabe: "TWEETY"

Bei String-Enums müssen wir jedem Mitglied einen Wert zuweisen. Es ist wie sicherzustellen, dass jedes deiner Haustiere seinen besonderen Nickname kennt!

Heterogene Enums

Manchmal ist das Leben nicht nur Zahlen oder nur Strings – es ist eine Mischung! Heterogene Enums sind wie eine Schachtel mit gemischten Pralinen – du bekommst ein bisschen von allem.

enum MixedBag {
Number = 1,
String = "STRING",
AnotherNumber = 2
}

console.log(MixedBag.Number);        // Ausgabe: 1
console.log(MixedBag.String);        // Ausgabe: "STRING"
console.log(MixedBag.AnotherNumber); // Ausgabe: 2

Obwohl dies möglich ist, wird generell empfohlen, in einem Enum entweder alle Zahlen oder alle Strings zu verwenden, um Konsistenz zu gewährleisten.

Enums zur Laufzeit

Eine coole Sache bei Enums ist, dass sie zur Laufzeit existieren. Das bedeutet, du kannst sie in deinem Code wie jedes andere Objekt verwenden!

enum Fruits {
Apple,
Banana,
Orange
}

function getFruitName(fruit: Fruits): string {
return Fruits[fruit];
}

console.log(getFruitName(Fruits.Apple));  // Ausgabe: "Apple"
console.log(getFruitName(Fruits.Banana)); // Ausgabe: "Banana"

Hier verwenden wir das Enum, als wäre es ein reguläres JavaScript-Objekt. Es ist wie ein magisches Wörterbuch, das Zahlen in Fruchtnamen übersetzen kann!

Enums zur Compile-Zeit

Enums leuchten auch zur Compile-Zeit. Sie helfen TypeScript, Fehler bereits vor dem Ausführen deines Codes zu erkennen!

enum DaysOfWeek {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}

let day: DaysOfWeek = DaysOfWeek.Monday;
day = DaysOfWeek.Friday;  // Das ist in Ordnung

// day = "Monday";  // Fehler: Der Typ '"Monday"' ist nicht zuweisbar an den Typ 'DaysOfWeek'.

TypeScript wird dir einen Fehler anzeigen, wenn du versuchst, einen Wert zuzuweisen, der nicht Teil des Enums ist. Es ist wie ein strenger Türsteher in einem Club, der nur die Wochentage hereinlässt!

Ambient Enums

Ambient Enums sind ein bisschen besonders. Sie werden verwendet, wenn du TypeScript über Enums informieren möchtest, die irgendwo else in deinem Code oder in einer Bibliothek, die du verwendest, existieren.

declare enum ExternalEnum {
A = 1,
B,
C = 2
}

Das Schlüsselwort declare ist wie "Hey TypeScript, vertraue mir, dieses Enum existiert irgendwo else im Code." Es ist nützlich, wenn du mit Code arbeitest, der nicht in TypeScript geschrieben wurde.

Objekt vs. Enums

Du könntest dich fragen, "Warum nicht einfach Objekte verwenden?"Nun, Enums haben einige Vorteile:

// Verwenden eines Objekts
const ColorObject = {
Red: 'RED',
Green: 'GREEN',
Blue: 'BLUE'
} as const;

// Verwenden eines Enums
enum ColorEnum {
Red = 'RED',
Green = 'GREEN',
Blue = 'BLUE'
}

// Mit Objekten musst du Typannahmen verwenden
let objColor: keyof typeof ColorObject = 'Red';

// Mit Enums ist es direkter
let enumColor: ColorEnum = ColorEnum.Red;

Enums bieten bessere Typensicherheit und sind in vielen Fällen kompakter.

Verwendung von Enum als Funktion parameter

Enums sind großartig für Funktion parameter. Sie machen deinen Code lesbarer und verhindern Fehler:

enum Sizes {
Small,
Medium,
Large
}

function orderCoffee(size: Sizes): string {
switch(size) {
case Sizes.Small:
return "Hier ist dein kleines Kaffee!";
case Sizes.Medium:
return "Ein mittlerer Kaffee kommt gleich!";
case Sizes.Large:
return "Großer Kaffee, extra Koffein!";
default:
return "Wir haben diese Größe nicht!";
}
}

console.log(orderCoffee(Sizes.Medium));  // Ausgabe: "Ein mittlerer Kaffee kommt gleich!"
// console.log(orderCoffee("Venti"));    // Fehler: Der Typ '"Venti"' ist nicht zuweisbar an den Typ 'Sizes'.

Durch die Verwendung eines Enums für den Größenparameter stellen wir sicher, dass nur gültige Größen an die Funktion übergeben werden können. Es ist wie ein Menü mit festen Optionen – keine Verwirrung darüber, welche Größen verfügbar sind!

Enum-Methoden

Hier ist eine Tabelle nützlicher Methoden zum Arbeiten mit Enums:

Methode	Beschreibung	Beispiel
Object.keys()	Alle Schlüssel eines Enums abrufen	Object.keys(Sizes)
Object.values()	Alle Werte eines Enums abrufen	Object.values(Sizes)
Object.entries()	Alle Schlüssel-Wert-Paare eines Enums abrufen	Object.entries(Sizes)
Enum[key]	Den Wert für einen Schlüssel abrufen	Sizes[Sizes.Small]
Enum[value]	Den Schlüssel für einen Wert abrufen (für numerische Enums)	Sizes[0]

Diese Methoden helfen dir, auf verschiedene Weisen mit Enums zu arbeiten, wie z.B. alle verfügbaren Größen abzurufen oder den Namen einer Größe basierend auf ihrem Wert zu finden.

Und das war's! Du hast gerade deine ersten Schritte in die Welt der TypeScript Enums gemacht. Erinnere dich daran, dass Programmieren wie das Lernen einer neuen Sprache ist – es erfordert Übung, aber bald wirst du fließend in Enum-speak sprechen! Bleib am Code, bleib neugierig und vergiss nicht, Spaß dabei zu haben. Wer weiß, vielleicht erstellst du nächstes Mal ein Enum für deine Lieblings-Eiscreme-Sorten!

Credits: Image by storyset