Comment utiliser les énumérations dans TypeScript étape par étape

Les énumérations dans TypeScript sont un moyen de définir un ensemble de constantes nommées qui peuvent être utilisées pour représenter une collection de valeurs liées. Elles rendent le code plus lisible et plus facile à gérer en donnant des noms conviviaux à ces valeurs. Ce guide vous guidera étape par étape dans l'utilisation des énumérations dans TypeScript, en couvrant leurs types, leurs avantages et des exemples pratiques.

Qu'est-ce qu'une énumération ?

Un enum (abréviation de "enumeration") est un type de données spécial dans TypeScript qui vous permet de définir un ensemble de constantes nommées. Ces constantes nommées peuvent représenter des valeurs numériques ou de chaîne, ce qui rend votre code plus descriptif et moins sujet aux erreurs.

Types d'énumérations dans TypeScript

Il existe trois types d'énumérations dans TypeScript:

• Énumérations numériques
• Énumérations de chaînes
• Enumérations hétérogènes

Énumérations numériques

Les énumérations numériques sont la valeur par défaut dans TypeScript. Il s'agit d'un ensemble de valeurs nommées auxquelles sont automatiquement attribuées des valeurs numériques à partir de 0 ou d'une valeur de départ personnalisée si elle est spécifiée.

Exemple d'énumération numérique de base

Vous trouverez ci-dessous un exemple simple d’énumération numérique:

enum Direction {
  Up,
  Down,
  Left,
  Right
}

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

Dans cet exemple, l'énumération Direction comporte quatre membres: Up, Down, Left et Right. Par défaut, Up se voit attribuer la valeur 0, Down est 1, et ainsi de suite. Vous pouvez également spécifier des valeurs numériques personnalisées pour les membres.

Énumération numérique avec valeurs personnalisées

Vous pouvez attribuer des valeurs personnalisées aux membres d’énumération:

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

Dans cet exemple, Nouveau est défini sur 1, En cours est automatiquement défini sur 2, Terminé est défini sur 5 et Annulé est automatiquement défini sur 6.

Énumérations de chaînes

Les énumérations de chaînes sont un autre type d'énumération où chaque membre est initialisé avec un littéral de chaîne, ce qui les rend plus lisibles et plus faciles à déboguer.

Exemple d'énumération de chaîne de base

Vous trouverez ci-dessous un exemple d’énumération de chaîne:

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

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

Dans cet exemple, chaque membre d'énumération est initialisé avec une valeur de chaîne. Contrairement aux énumérations numériques, les énumérations de chaîne n'ont pas de valeurs auto-incrémentées.

Enumérations hétérogènes

Les énumérations hétérogènes sont des énumérations qui contiennent à la fois des membres de type chaîne et numérique. Bien qu'il soit possible de les définir, cela n'est généralement pas recommandé car cela peut entraîner des confusions et des erreurs dans le code.

Exemple d'énumération hétérogène

Voici un exemple d’énumération hétérogène:

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

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

Dans cet exemple, MixedEnum contient à la fois des valeurs de chaîne et des valeurs numériques. Utilisez ces énumérations avec précaution car elles peuvent prêter à confusion.

Cas d'utilisation d'Enum

Les énumérations sont utiles dans divers scénarios:

• Représentant un ensemble de constantes liées comme les directions (haut, bas, gauche, droite).
• Définition des états dans une machine à états (Nouveau, En cours, Terminé, Annulé).
• Utilisez-les dans des instructions switch-case pour une meilleure lisibilité.

Enum dans un exemple de cas de commutation

L'utilisation d'énumérations dans une instruction switch-case améliore la lisibilité du code et facilite la gestion des états.

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

Dans cet exemple, l'instruction switch-case est plus lisible et moins sujette aux erreurs, grâce à l'utilisation d'énumérations.

Conclusion

Les énumérations dans TypeScript offrent un moyen puissant de définir un ensemble de constantes nommées, améliorant ainsi la lisibilité du code et la sécurité des types. En utilisant des énumérations numériques, de chaîne ou même hétérogènes, vous pouvez mieux gérer et organiser votre code. Grâce à ce guide étape par étape, vous devriez maintenant être à l'aise avec l'utilisation des énumérations dans TypeScript pour rendre votre code plus propre et plus facile à gérer.