Hur man använder Enums i TypeScript steg-för-steg

Enums i TypeScript är ett sätt att definiera en uppsättning namngivna konstanter som kan användas för att representera en samling relaterade värden. De gör koden mer läsbar och underhållbar genom att ge dessa värden vänliga namn. Den här guiden går igenom hur du använder enums i TypeScript steg-för-steg, och täcker deras typer, fördelar och praktiska exempel.

Vad är en Enum?

En enum (förkortning av "enumeration") är en speciell datatyp i TypeScript som låter dig definiera en uppsättning namngivna konstanter. Dessa namngivna konstanter kan representera numeriska eller strängvärden, vilket gör din kod mer beskrivande och mindre felbenägen.

Typer av uppräkningar i TypeScript

Det finns tre typer av enums i TypeScript:

• Numeriska uppräkningar
• String Enums
• Heterogena uppräkningar

Numeriska uppräkningar

Numeriska uppräkningar är standard i TypeScript. De är en uppsättning namngivna värden som automatiskt tilldelas numeriska värden från 0, eller från ett anpassat startvärde om det anges.

Grundläggande numeriskt uppräkningsexempel

Nedan är ett enkelt exempel på en numerisk uppräkning:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

let move: Direction = Direction.Up;
console.log(move); // Output: 0

I det här exemplet har Direction enum fyra medlemmar: Upp, Ner, Vänster och Höger. Som standard tilldelas Upp värdet 0, Ned är 1 och så vidare. Du kan också ange anpassade numeriska värden för medlemmarna.

Numerisk uppräkning med anpassade värden

Du kan tilldela anpassade värden till uppräkning av medlemmar:

enum Status {
  New = 1,
  InProgress,
  Done = 5,
  Cancelled
}

console.log(Status.New); // Output: 1
console.log(Status.InProgress); // Output: 2
console.log(Status.Done); // Output: 5
console.log(Status.Cancelled); // Output: 6

I det här exemplet är Ny satt till 1, Pågående är automatiskt inställd på 2, Klar är inställd till 5, och Avbruten ställs automatiskt in på 6.

String Enums

String enums är en annan typ av enum där varje medlem initieras med en sträng literal, vilket gör dem mer läsbara och lättare att felsöka.

Basic String Enum Exempel

Nedan är ett exempel på en stränguppräkning:

enum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT"
}

let move: Direction = Direction.Left;
console.log(move); // Output: "LEFT"

I det här exemplet initieras varje enum-medlem med ett strängvärde. Till skillnad från numeriska uppräkningar har inte stränguppräkningar automatiskt inkrementerade värden.

Heterogena uppräkningar

Heterogena enums är enums som innehåller både sträng- och numeriska medlemmar. Även om det är möjligt att definiera dem, rekommenderas det i allmänhet inte eftersom det kan leda till förvirring och fel i koden.

Heterogena Enum Exempel

Här är ett exempel på en heterogen enum:

enum MixedEnum {
  Yes = "YES",
  No = 0,
  Maybe = 1
}

console.log(MixedEnum.Yes); // Output: "YES"
console.log(MixedEnum.No); // Output: 0

I det här exemplet innehåller MixedEnum både strängvärden och numeriska värden. Använd sådana uppräkningar försiktigt eftersom de kan orsaka förvirring.

Enum Användningsfall

Uppräkningar är användbara i en mängd olika scenarier:

• Representerar en uppsättning relaterade konstanter som riktningar (Upp, Ner, Vänster, Höger).
• Definiera tillstånd i en tillståndsmaskin (Ny, Pågående, Klar, Avbruten).
• Använda dem i switch-case-satser för bättre läsbarhet.

Enum i ett Switch-Case Exempel

Att använda enums i en switch-case-sats förbättrar kodläsbarheten och gör det lättare att hantera tillstånd.

enum Status {
  New,
  InProgress,
  Done,
  Cancelled
}

function getStatusMessage(status: Status): string {
  switch (status) {
    case Status.New:
      return "The task is new.";
    case Status.InProgress:
      return "The task is in progress.";
    case Status.Done:
      return "The task is completed.";
    case Status.Cancelled:
      return "The task is cancelled.";
    default:
      return "Unknown status.";
  }
}

console.log(getStatusMessage(Status.InProgress)); // Output: "The task is in progress."

I det här exemplet är switch-case-satsen mer läsbar och mindre benägen för fel, tack vare att enums används.

Slutsats

Enums i TypeScript ger ett kraftfullt sätt att definiera en uppsättning namngivna konstanter, vilket förbättrar kodläsbarhet och typsäkerhet. Genom att använda numeriska, strängar eller till och med heterogena uppräkningar kan du bättre hantera och organisera din kod. Med den här steg-för-steg-guiden bör du nu vara bekväm med att använda enums i TypeScript för att göra din kod renare och mer underhållsbar.