Cum să utilizați enumerarea în TypeScript pas cu pas

Enumerările din TypeScript sunt o modalitate de a defini un set de constante numite care pot fi utilizate pentru a reprezenta o colecție de valori înrudite. Ele fac codul mai lizibil și mai ușor de întreținut, dând nume prietenoase acestor valori. Acest ghid vă va ghida prin utilizarea enumărilor în TypeScript pas cu pas, acoperind tipurile, beneficiile și exemplele practice ale acestora.

Ce este o Enum?

Un enum (prescurtare de la "enumeration") este un tip de date special în TypeScript care vă permite să definiți un set de constante denumite. Aceste constante numite pot reprezenta valori numerice sau șir, făcând codul mai descriptiv și mai puțin predispus la erori.

Tipuri de enumerari în TypeScript

Există trei tipuri de enumerari în TypeScript:

• Enumări numerice
• Enumări șiruri
• Enumări eterogene

Enumări numerice

Enumerările numerice sunt implicite în TypeScript. Sunt un set de valori numite cărora li se atribuie automat valori numerice începând de la 0 sau de la o valoare de pornire personalizată, dacă este specificată.

Exemplu de enumerare numerică de bază

Mai jos este un exemplu simplu de enumerare numerică:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

În acest exemplu, enumerarea Direction are patru membri: Up, Down, Left și Right. În mod implicit, Up i se atribuie valoarea 0, Down este 1 și așa mai departe. De asemenea, puteți specifica valori numerice personalizate pentru membri.

Enum numeric cu valori personalizate

Puteți atribui valori personalizate membrilor enumerației:

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

În acest exemplu, New este setat la 1, InProgress este setat automat la 2, Done este setat la 5, iar Anulat este setat automat la 6.

Enumări șiruri

Enumerările șirurilor sunt un alt tip de enumerare în care fiecare membru este inițializat cu un literal șir, făcându-le mai lizibile și mai ușor de depanat.

Exemplu de enumerare a șirurilor de caractere de bază

Mai jos este un exemplu de enumerare de șir:

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

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

În acest exemplu, fiecare membru de enumerare este inițializat cu o valoare șir. Spre deosebire de enumerarile numerice, enumerarile de siruri nu au valori incrementate automat.

Enumări eterogene

Enumerările eterogene sunt enumerări care conțin atât membri șir, cât și membri numerici. Deși este posibil să le definiți, în general nu este recomandat, deoarece poate duce la confuzii și erori în cod.

Exemplu Enum eterogen

Iată un exemplu de enumerare eterogenă:

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

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

În acest exemplu, MixedEnum conține atât valori șir, cât și valori numerice. Utilizați astfel de enumerari cu precauție, deoarece pot provoca confuzie.

Enumerare cazuri de utilizare

Enumerările sunt utile într-o varietate de scenarii:

• Reprezentând un set de constante înrudite, cum ar fi direcțiile (Sus, Jos, Stânga, Dreapta).
• Definirea stărilor într-o mașină de stări (Nou, În curs, Terminat, Anulat).
• Folosindu-le în declarațiile switch-case pentru o mai bună lizibilitate.

Enum într-un exemplu de caz de comutare

Utilizarea enumărilor într-o declarație switch-case îmbunătățește lizibilitatea codului și face mai ușoară gestionarea stărilor.

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

În acest exemplu, instrucțiunea switch-case este mai lizibilă și mai puțin predispusă la erori, datorită utilizării enumărilor.

Concluzie

Enumerările din TypeScript oferă o modalitate puternică de a defini un set de constante denumite, îmbunătățind lizibilitatea codului și siguranța tipului. Folosind enumerari numerice, șir sau chiar eterogene, vă puteți gestiona și organiza mai bine codul. Cu acest ghid pas cu pas, acum ar trebui să vă simțiți confortabil folosind enumerări în TypeScript pentru a face codul mai curat și mai ușor de întreținut.