Cómo usar enumeraciones en TypeScript paso a paso

Las enumeraciones en TypeScript son una forma de definir un conjunto de constantes con nombre que se pueden usar para representar una colección de valores relacionados. Hacen que el código sea más legible y fácil de mantener al darles nombres fáciles de entender a estos valores. Esta guía lo guiará paso a paso en el uso de enumeraciones en TypeScript, abarcando sus tipos, beneficios y ejemplos prácticos.

¿Qué es una enumeración?

Una enum (abreviatura de "enumeration") es un tipo de datos especial en TypeScript que permite definir un conjunto de constantes con nombre. Estas constantes con nombre pueden representar valores numéricos o de cadena, lo que hace que el código sea más descriptivo y menos propenso a errores.

Tipos de enumeraciones en TypeScript

Hay tres tipos de enumeraciones en TypeScript:

• Enumeraciones numéricas
• Enumeraciones de cadenas
• Enumeraciones heterogéneas

Enumeraciones numéricas

Las enumeraciones numéricas son predeterminadas en TypeScript. Son un conjunto de valores con nombre a los que se les asignan valores numéricos automáticamente a partir de 0 o de un valor inicial personalizado si se especifica.

Ejemplo básico de enumeración numérica

A continuación se muestra un ejemplo simple de una enumeración numérica:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

En este ejemplo, la enumeración Direction tiene cuatro miembros: Up, Down, Left y Right. De forma predeterminada, a Up se le asigna el valor 0, a Down se le asigna el valor 1, y así sucesivamente. También puede especificar valores numéricos personalizados para los miembros.

Enumeración numérica con valores personalizados

Puede asignar valores personalizados a los miembros de enumeración:

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

En este ejemplo, New se establece en 1, InProgress se establece automáticamente en 2, Done se establece en 5 y Cancelled se establece automáticamente en 6.

Enumeraciones de cadenas

Las enumeraciones de cadenas son otro tipo de enumeración donde cada miembro se inicializa con un literal de cadena, lo que las hace más legibles y fáciles de depurar.

Ejemplo básico de enumeración de cadenas

A continuación se muestra un ejemplo de una enumeración de cadena:

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

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

En este ejemplo, cada miembro de enumeración se inicializa con un valor de cadena. A diferencia de las enumeraciones numéricas, las enumeraciones de cadena no tienen valores que se incrementan automáticamente.

Enumeraciones heterogéneas

Las enumeraciones heterogéneas son enumeraciones que contienen tanto cadenas como números. Si bien es posible definirlas, generalmente no se recomienda hacerlo, ya que puede generar confusión y errores en el código.

Ejemplo de enumeración heterogénea

A continuación se muestra un ejemplo de una enumeración heterogénea:

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

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

En este ejemplo, MixedEnum contiene valores numéricos y de cadena. Utilice estas enumeraciones con precaución, ya que pueden causar confusión.

Casos de uso de enumeraciones

Las enumeraciones son útiles en una variedad de escenarios:

• Representa un conjunto de constantes relacionadas como direcciones (Arriba, Abajo, Izquierda, Derecha).
• Definición de estados en una máquina de estados (Nuevo, En progreso, Listo, Cancelado).
• Utilizándolos en declaraciones switch-case para una mejor legibilidad.

Ejemplo de enumeración en el caso Switch

El uso de enumeraciones en una declaración switch-case mejora la legibilidad del código y facilita la gestión 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."

En este ejemplo, la declaración switch-case es más legible y menos propensa a errores, gracias al uso de enumeraciones.

Conclusión

Las enumeraciones en TypeScript proporcionan una forma eficaz de definir un conjunto de constantes con nombre, lo que mejora la legibilidad del código y la seguridad de los tipos. Al utilizar enumeraciones numéricas, de cadena o incluso heterogéneas, puede administrar y organizar mejor su código. Con esta guía paso a paso, ahora debería sentirse cómodo con el uso de enumeraciones en TypeScript para que su código sea más limpio y fácil de mantener.