TypeScript - Enums : Guide pour débutants

Bonjour, futurs programmeurs ! Aujourd'hui, nous allons plonger dans le merveilleux monde des Enums de TypeScript. Ne vous inquiétez pas si vous n'avez jamais programmé auparavant - je serai votre guide amical tout au long de ce voyage, comme j'ai été pour des centaines d'étudiants au fil des ans. Alors, c'est parti !

Qu'est-ce que les Enums ?

Avant de nous pencher sur les différents types d'Enums, comprenons ce qu'ils sont. Imaginez que vous organisez votre placard. Vous pourriez avoir différentes catégories pour vos vêtements : chemises, pantalons, chaussures, etc. Les Enums en TypeScript sont comme ces catégories - elles nous aident à regrouper des valeurs liées et à leur donner des noms significatifs.

Enums numériques

Les Enums numériques sont le type d'Enums le plus commun en TypeScript. Ils sont comme assigner des nombres à vos super-héros préférés.

enum Superheroes {
Superman,
Batman,
WonderWoman,
Flash
}

console.log(Superheroes.Superman);  // Output: 0
console.log(Superheroes.Batman);    // Output: 1
console.log(Superheroes.WonderWoman);  // Output: 2
console.log(Superheroes.Flash);     // Output: 3

Dans cet exemple, TypeScript assigne automatiquement des nombres en partant de 0. Superman obtient 0, Batman obtient 1, et ainsi de suite. C'est comme s'ils se mettaient en ligne pour un groupe photo, et qu'on leur attribuait des numéros en fonction de leur position !

Mais que se passe-t-il si nous voulons commencer avec un nombre différent ? Pas de problème ! Nous pouvons aussi faire cela :

enum Villains {
Joker = 1,
LexLuthor,
Cheetah,
ReverseFlash
}

console.log(Villains.Joker);        // Output: 1
console.log(Villains.LexLuthor);    // Output: 2
console.log(Villains.Cheetah);      // Output: 3
console.log(Villains.ReverseFlash); // Output: 4

Ici, nous avons dit à TypeScript de commencer à compter à partir de 1 pour Joker, et il a continué automatiquement pour le reste.

Enums de chaînes

Maintenant, disons que vous n'êtes pas fan des nombres et que vous préférez les mots. C'est là que les Enums de chaînes deviennent utiles. Ils sont comme donner des surnoms à vos animaux de compagnie !

enum PetNames {
Dog = "BUDDY",
Cat = "WHISKERS",
Fish = "BUBBLES",
Bird = "TWEETY"
}

console.log(PetNames.Dog);   // Output: "BUDDY"
console.log(PetNames.Cat);   // Output: "WHISKERS"
console.log(PetNames.Fish);  // Output: "BUBBLES"
console.log(PetNames.Bird);  // Output: "TWEETY"

Avec les Enums de chaînes, nous devons donner une valeur à chaque membre. C'est comme nous assurer que chacun de nos animaux de compagnie connaît leur surnom spécial !

Enums hétérogènes

Parfois, la vie n'est pas seulement composée de nombres ou de chaînes - c'est un mélange ! Les Enums hétérogènes sont comme une boîte de chocolats mélangés - vous en avez un peu de tout.

enum MixedBag {
Number = 1,
String = "STRING",
AnotherNumber = 2
}

console.log(MixedBag.Number);        // Output: 1
console.log(MixedBag.String);        // Output: "STRING"
console.log(MixedBag.AnotherNumber); // Output: 2

Bien que cela soit possible, il est généralement recommandé de s'en tenir soit à des nombres, soit à des chaînes dans un Enum pour maintenir la cohérence.

Enums en temps d'exécution

Une chose sympa à propos des Enums, c'est qu'ils existent en temps d'exécution. Cela signifie que vous pouvez les utiliser dans votre code comme n'importe quel autre objet !

enum Fruits {
Apple,
Banana,
Orange
}

function getFruitName(fruit: Fruits): string {
return Fruits[fruit];
}

console.log(getFruitName(Fruits.Apple));  // Output: "Apple"
console.log(getFruitName(Fruits.Banana)); // Output: "Banana"

Ici, nous utilisons l'Enum comme si c'était un objet JavaScript régulier. C'est comme avoir un dictionnaire magique qui peut traduire les nombres en noms de fruits !

Enums en temps de compilation

Les Enums brillent également en temps de compilation. Ils aident TypeScript à attraper des erreurs avant même que votre code ne s'exécute !

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

let day: DaysOfWeek = DaysOfWeek.Monday;
day = DaysOfWeek.Friday;  // C'est correct

// day = "Monday";  // Erreur : Le type '"Monday"' n'est pas assignable au type 'DaysOfWeek'.

TypeScript vous donnera une erreur si vous essayez d'assigner une valeur qui n'est pas partie de l'Enum. C'est comme avoir un vigile strict à une boîte de nuit qui n'laisse entrer que les jours de la semaine !

Enums ambiants

Les Enums ambiants sont un peu spéciaux. Ils sont utilisés lorsque vous dites à TypeScript que des Enums existent ailleurs dans votre code ou dans une bibliothèque que vous utilisez.

declare enum ExternalEnum {
A = 1,
B,
C = 2
}

Le mot-clé declare est comme dire, "Eh TypeScript, fais-moi confiance, cet Enum existe quelque part ailleurs dans le code." C'est utile lorsque vous travaillez avec du code qui n'est pas écrit en TypeScript.

Objets vs Enums

Vous vous demandez peut-être, "Pourquoi ne pas utiliser des objets ?" Eh bien, les Enums ont certains avantages :

// Utilisation d'un objet
const ColorObject = {
Red: 'RED',
Green: 'GREEN',
Blue: 'BLUE'
} as const;

// Utilisation d'un Enum
enum ColorEnum {
Red = 'RED',
Green = 'GREEN',
Blue = 'BLUE'
}

// Avec des objets, vous devez utiliser des assertions de type
let objColor: keyof typeof ColorObject = 'Red';

// Avec des Enums, c'est plus direct
let enumColor: ColorEnum = ColorEnum.Red;

Les Enums offrent une meilleure sécurité de type et sont plus concis dans de nombreux cas.

Utilisation des Enums comme paramètres de fonction

Les Enums sont géniaux pour les paramètres de fonction. Ils rendent votre code plus lisible et préviennent les erreurs :

enum Sizes {
Small,
Medium,
Large
}

function orderCoffee(size: Sizes): string {
switch(size) {
case Sizes.Small:
return "Voici votre petit café !";
case Sizes.Medium:
return "Un café medium arrive tout de suite !";
case Sizes.Large:
return "Grand café, avec un supplément de caféine !";
default:
return "Nous n'avons pas cette taille !";
}
}

console.log(orderCoffee(Sizes.Medium));  // Output: "Un café medium arrive tout de suite !"
// console.log(orderCoffee("Venti"));    // Erreur : L'argument de type '"Venti"' n'est pas assignable au paramètre de type 'Sizes'.

En utilisant un Enum pour le paramètre de taille, nous nous assurons que seules les tailles valides peuvent être passées à la fonction. C'est comme avoir un menu avec des options fixes - pas de confusion quant aux tailles disponibles !

Méthodes des Enums

Voici un tableau des méthodes utiles pour travailler avec les Enums :

Méthode	Description	Exemple
Object.keys()	Obtient toutes les clés d'un Enum	Object.keys(Sizes)
Object.values()	Obtient toutes les valeurs d'un Enum	Object.values(Sizes)
Object.entries()	Obtient les paires clé-valeur d'un Enum	Object.entries(Sizes)
Enum[key]	Obtient la valeur pour une clé	Sizes[Sizes.Small]
Enum[value]	Obtient la clé pour une valeur (pour les Enums numériques)	Sizes[0]

Ces méthodes vous aident à travailler avec les Enums de différentes manières, comme obtenir toutes les tailles disponibles ou trouver le nom d'une taille à partir de sa valeur.

Et voilà ! Vous avez刚刚 fait vos premiers pas dans le monde des Enums de TypeScript. Souvenez-vous, la programmation est comme apprendre une nouvelle langue - cela prend de la pratique, mais bientôt vous serez couramment en Enum-speak ! Continuez à coder, restez curieux, et n'oubliez pas de vous amuser en cours de route. Qui sait, peut-être créerez-vous un Enum pour vos saveurs de glace préférées prochaînement !

Credits: Image by storyset