Jak używać wyliczeń w TypeScript krok po kroku

Wyliczenia w TypeScript to sposób definiowania zestawu nazwanych stałych, których można użyć do reprezentowania zbioru powiązanych wartości. Sprawiają, że kod jest bardziej czytelny i łatwiejszy w utrzymaniu, nadając tym wartościom przyjazne nazwy. Ten przewodnik przeprowadzi Cię przez używanie wyliczeń w TypeScript krok po kroku, obejmując ich typy, korzyści i praktyczne przykłady.

Czym jest Enum?

enum (skrót od "enumeration") to specjalny typ danych w TypeScript, który umożliwia zdefiniowanie zestawu nazwanych stałych. Te nazwane stałe mogą reprezentować wartości liczbowe lub ciągi znaków, dzięki czemu kod jest bardziej opisowy i mniej podatny na błędy.

Typy wyliczeń w TypeScript

W TypeScript istnieją trzy typy wyliczeń:

• Wyliczenia numeryczne
• Wyliczenia ciągów
• Heterogeniczne wyliczenia

Wyliczenia numeryczne

Wyliczenia numeryczne są domyślne w TypeScript. Są to zestawy nazwanych wartości, którym automatycznie przypisuje się wartości numeryczne zaczynając od 0 lub od niestandardowej wartości początkowej, jeśli została określona.

Przykład podstawowego wyliczenia numerycznego

Poniżej znajduje się prosty przykład wyliczenia numerycznego:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

W tym przykładzie wyliczenie Direction ma cztery elementy: Up, Down, Left i Right. Domyślnie Up ma przypisaną wartość 0, Down ma wartość 1 itd. Można również określić niestandardowe wartości liczbowe dla elementów.

Wyliczenie numeryczne z wartościami niestandardowymi

Można przypisać niestandardowe wartości do elementów wyliczenia:

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

W tym przykładzie Nowy jest ustawiony na 1, W toku jest automatycznie ustawiane na 2, Gotowe jest ustawione na 5, a Anulowane jest automatycznie ustawiane na 6.

Wyliczenia ciągów

Wyliczenia łańcuchowe to kolejny typ wyliczeń, w których każdy element jest inicjowany literałem łańcuchowym, co czyni je bardziej czytelnymi i łatwiejszymi do debugowania.

Przykład podstawowego wyliczenia ciągów

Poniżej znajduje się przykład wyliczenia ciągu:

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

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

W tym przykładzie każdy element wyliczenia jest inicjowany wartością ciągu. W przeciwieństwie do wyliczeń numerycznych, wyliczenia ciągu nie mają wartości automatycznie zwiększanych.

Heterogeniczne wyliczenia

Heterogeniczne wyliczenia to wyliczenia zawierające zarówno elementy stringowe, jak i numeryczne. Chociaż możliwe jest ich zdefiniowanie, generalnie nie jest to zalecane, ponieważ może prowadzić do zamieszania i błędów w kodzie.

Przykład wyliczenia heterogenicznego

Oto przykład heterogenicznego wyliczenia:

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

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

W tym przykładzie MixedEnum zawiera zarówno wartości string, jak i numeryczne. Używaj takich wyliczeń ostrożnie, ponieważ mogą powodować zamieszanie.

Przypadki użycia Enum

Wyliczenia są pomocne w wielu sytuacjach:

• Reprezentuje zestaw powiązanych ze sobą stałych, takich jak kierunki (w górę, w dół, w lewo, w prawo).
• Definiowanie stanów w maszynie stanowej (Nowy, W toku, Gotowe, Anulowane).
• Używaj ich w poleceniach switch-case w celu zwiększenia czytelności.

Przykład wyliczenia w przypadku przełącznika

Użycie typów wyliczeniowych w instrukcji switch-case poprawia czytelność kodu i ułatwia zarządzanie stanami.

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."

W tym przykładzie instrukcja switch-case jest bardziej czytelna i mniej podatna na błędy dzięki zastosowaniu typów wyliczeniowych.

Wniosek

Wyliczenia w TypeScript zapewniają potężny sposób definiowania zestawu nazwanych stałych, poprawiając czytelność kodu i bezpieczeństwo typu. Używając wyliczeń numerycznych, łańcuchowych, a nawet heterogenicznych, możesz lepiej zarządzać kodem i go organizować. Dzięki temu przewodnikowi krok po kroku powinieneś teraz swobodnie używać wyliczeń w TypeScript, aby kod był czystszy i łatwiejszy w utrzymaniu.