Sådan bruges Enums i TypeScript trin-for-trin

Enums i TypeScript er en måde at definere et sæt af navngivne konstanter, der kan bruges til at repræsentere en samling af relaterede værdier. De gør koden mere læsbar og vedligeholdelig ved at give disse værdier venlige navne. Denne vejledning vil lede dig gennem brugen af ​​enums i TypeScript trin-for-trin, der dækker deres typer, fordele og praktiske eksempler.

Hvad er en Enum?

En enum (forkortelse for "enumeration") er en speciel datatype i TypeScript, der giver dig mulighed for at definere et sæt navngivne konstanter. Disse navngivne konstanter kan repræsentere numeriske værdier eller strengværdier, hvilket gør din kode mere beskrivende og mindre udsat for fejl.

Typer af enums i TypeScript

Der er tre typer enums i TypeScript:

• Numeriske enums
• Strengoptegnelser
• Heterogene Enums

Numeriske enums

Numeriske enums er standard i TypeScript. De er et sæt navngivne værdier, der automatisk tildeles numeriske værdier startende fra 0 eller fra en brugerdefineret startværdi, hvis det er angivet.

Grundlæggende numerisk enum eksempel

Nedenfor er et simpelt eksempel på en numerisk enum:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

I dette eksempel har Retning enum fire medlemmer: Op, Ned, Venstre og Højre. Som standard er Op tildelt værdien 0, Ned er 1, og så videre. Du kan også angive brugerdefinerede numeriske værdier for medlemmerne.

Numerisk enum med brugerdefinerede værdier

Du kan tildele brugerdefinerede værdier til enumre medlemmer:

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 dette eksempel er Ny sat til 1, Igangværende er automatisk indstillet til 2, Udført er indstillet til 5, og Annulleret indstilles automatisk til 6.

Strengoptegnelser

String enums er en anden type enum, hvor hvert medlem initialiseres med en streng literal, hvilket gør dem mere læsbare og nemmere at fejlsøge.

Basic String Enum Eksempel

Nedenfor er et eksempel på en strengenum:

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

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

I dette eksempel initialiseres hvert enum-medlem med en strengværdi. I modsætning til numeriske enums har strengenums ikke automatisk forøgede værdier.

Heterogene Enums

Heterogene enums er enums, der indeholder både streng og numeriske medlemmer. Selvom det er muligt at definere dem, anbefales det generelt ikke, da det kan føre til forvirring og fejl i kode.

Eksempel på heterogen enum

Her er et eksempel 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 dette eksempel indeholder MixedEnum både streng og numeriske værdier. Brug sådanne optegnelser forsigtigt, da de kan forårsage forvirring.

Enum Use Cases

Enums er nyttige i en række forskellige scenarier:

• Repræsenterer et sæt af relaterede konstanter som retninger (Op, Ned, Venstre, Højre).
• Definition af tilstande i en tilstandsmaskine (Ny, Igangværende, Udført, Annulleret).
• Brug dem i switch-case statements for bedre læsbarhed.

Enum i et Switch-Case Eksempel

Brug af enums i en switch-case-sætning forbedrer kodelæsbarheden og gør det nemmere at administrere tilstande.

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 dette eksempel er switch-case-sætningen mere læsbar og mindre tilbøjelig til fejl, takket være brugen af ​​enums.

Konklusion

Enums i TypeScript giver en effektiv måde at definere et sæt af navngivne konstanter, hvilket forbedrer kodelæsbarhed og typesikkerhed. Ved at bruge numeriske, strenge eller endda heterogene enums kan du bedre administrere og organisere din kode. Med denne trinvise vejledning bør du nu være fortrolig med at bruge enums i TypeScript for at gøre din kode renere og mere vedligeholdelsesvenlig.