Énumérations

Bienvenue dans la prochaine leçon ! Dans cette leçon, vous découvrirez les énumérations en TypeScript. Les énumérations vous permettent de définir un ensemble de constantes nommées, ce qui rend votre code plus lisible et plus facile à gérer. Plongeons dans le sujet !

Que sont les énumérations ?

Une énumération (abrégée en « énumération ») est un type de données qui vous permet de définir un ensemble de constantes nommées. Les énumérations servent à regrouper des valeurs associées, ce qui rend votre code mieux organisé et moins sujet aux erreurs.

Exemple : L’énumération Days permet de représenter les jours de la semaine :

Tâche : Créez une énumération pour les mois de l’année et journalisez certaines valeurs.

enum Days {
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday,
}

console.log(Days.Monday); // Output: 0
console.log(Days.Friday); // Output: 4

Énumérations numériques

Les énumérations TypeScript sont numériques par défaut et commencent à 0. Vous pouvez attribuer des valeurs personnalisées aux membres de l’énumération si nécessaire :

Tâche : Définissez une énumération pour les rôles utilisateur (par exemple : Administrateur, Éditeur, Observateur) avec des valeurs numériques personnalisées.

enum Status {
  Active = 1,
  Inactive = 2,
  Pending = 3,
}

console.log(Status.Active); // Output: 1
console.log(Status.Pending); // Output: 3

Mappage inverse

Les énumérations TypeScript prennent en charge le mappage inverse, ce qui vous permet d’obtenir le nom d’un membre de l’énumération à partir de sa valeur :

Tâche : Expérimentez le mappage inverse avec votre propre énumération.

enum Colors {
  Red = 1,
  Green,
  Blue,
}

console.log(Colors[1]); // Output: "Red"
console.log(Colors[2]); // Output: "Green"

Énumérations de chaînes

TypeScript prend également en charge les énumérations de chaînes, dans lesquelles chaque membre de l’énumération reçoit une valeur de type chaîne :

Tâche : Créez une énumération de chaînes pour les couleurs primaires (par exemple : Rouge, Vert, Bleu).

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

console.log(Directions.Up); // Output: "UP"
console.log(Directions.Left); // Output: "LEFT"

Énumérations hétérogènes

Une énumération peut contenir à la fois des valeurs numériques et des chaînes, mais cette pratique est généralement déconseillée par souci de cohérence :

Tâche : Définissez une énumération mixte et observez son comportement dans votre éditeur.

enum Mixed {
  Yes = 1,
  No = "NO",
}

console.log(Mixed.Yes); // Output: 1
console.log(Mixed.No); // Output: "NO"

Utiliser les énumérations dans les fonctions

Les énumérations sont très utiles pour contrôler le flux de votre code. Exemple :

Tâche : Écrivez une fonction qui accepte une énumération en paramètre et renvoie un message.

enum Status {
  Active,
  Inactive,
  Pending,
}

function checkStatus(status: Status): string {
  switch (status) {
    case Status.Active:
      return "The status is active.";
    case Status.Inactive:
      return "The status is inactive.";
    case Status.Pending:
      return "The status is pending.";
    default:
      return "Unknown status.";
  }
}

console.log(checkStatus(Status.Active)); // Output: "The status is active."

Erreurs courantes

Voici quelques erreurs courantes lors de l’utilisation des énumérations :

• Utiliser des énumérations numériques alors que des énumérations de chaînes rendraient le code plus clair.
• Mélanger des valeurs numériques et des chaînes dans la même énumération.
• Ne pas utiliser d’énumérations pour des valeurs qui gagneraient à être des constantes nommées.

Conseil : Choisissez le type d’énumération approprié (numérique ou chaîne) en fonction de votre cas d’utilisation.

Bravo !

Félicitations ! Vous avez appris à utiliser les énumérations en TypeScript pour définir des constantes nommées. Les énumérations constituent un moyen puissant de rendre votre code plus lisible et moins sujet aux erreurs. Dans la prochaine leçon, nous explorerons les types littéraux, une autre fonctionnalité avancée de TypeScript. Continuons à coder !