Como usar enums em TypeScript passo a passo

Enums em TypeScript são uma maneira de definir um conjunto de constantes nomeadas que podem ser usadas para representar uma coleção de valores relacionados. Eles tornam o código mais legível e sustentável ao dar nomes amigáveis ​​a esses valores. Este guia o guiará pelo uso de enums em TypeScript passo a passo, abordando seus tipos, benefícios e exemplos práticos.

O que é uma enumeração?

Um enum (abreviação de "enumeration") é um tipo de dado especial em TypeScript que permite que você defina um conjunto de constantes nomeadas. Essas constantes nomeadas podem representar valores numéricos ou de string, tornando seu código mais descritivo e menos propenso a erros.

Tipos de Enums em TypeScript

Existem três tipos de enumerações no TypeScript:

• Enumerações Numéricas
• Enumerações de strings
• Enumerações heterogêneas

Enumerações Numéricas

Enums numéricos são o padrão no TypeScript. Eles são um conjunto de valores nomeados que são atribuídos automaticamente a valores numéricos começando em 0, ou a partir de um valor inicial personalizado, se especificado.

Exemplo básico de enumeração numérica

Abaixo está um exemplo simples de uma enumeração numérica:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

Neste exemplo, a enumeração Direction tem quatro membros: Up, Down, Left e Right. Por padrão, Up recebe o valor 0, Down é 1 e assim por diante. Você também pode especificar valores numéricos personalizados para os membros.

Enum numérico com valores personalizados

Você pode atribuir valores personalizados aos membros enum:

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

Neste exemplo, Novo é definido como 1, EmProgresso é definido automaticamente como 2, Concluído é definido como 5 e Cancelado é definido automaticamente como 6.

Enumerações de strings

Enums de string são outro tipo de enum em que cada membro é inicializado com um literal de string, tornando-os mais legíveis e fáceis de depurar.

Exemplo básico de enumeração de string

Abaixo está um exemplo de uma enumeração de string:

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

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

Neste exemplo, cada membro enum é inicializado com um valor string. Diferentemente de enums numéricos, enums string não têm valores autoincrementados.

Enumerações heterogêneas

Enums heterogêneos são enums que contêm membros de string e numéricos. Embora seja possível defini-los, geralmente não é recomendado, pois pode levar a confusão e erros no código.

Exemplo de enumeração heterogênea

Aqui está um exemplo de uma enumeração heterogênea:

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

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

Neste exemplo, MixedEnum contém valores de string e numéricos. Use tais enums com cautela, pois podem causar confusão.

Casos de uso de Enum

Enums são úteis em uma variedade de cenários:

• Representando um conjunto de constantes relacionadas, como direções (Cima, Baixo, Esquerda, Direita).
• Definindo estados em uma máquina de estados (Novo, Em andamento, Concluído, Cancelado).
• Usá-los em instruções switch-case para melhor legibilidade.

Exemplo de Enum em um Switch-Case

Usar enums em uma instrução switch-case melhora a legibilidade do código e facilita o gerenciamento de estados.

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

Neste exemplo, a instrução switch-case é mais legível e menos propensa a erros, graças ao uso de enumerações.

Conclusão

Enums no TypeScript fornecem uma maneira poderosa de definir um conjunto de constantes nomeadas, melhorando a legibilidade do código e a segurança do tipo. Ao usar enums numéricos, de string ou mesmo heterogêneos, você pode gerenciar e organizar melhor seu código. Com este guia passo a passo, agora você deve estar confortável usando enums no TypeScript para tornar seu código mais limpo e mais sustentável.