Un guide sur la façon de travailler avec

TypeScript, une extension de JavaScript, améliore la sécurité de votre code.

Grâce à TypeScript, la détection et la correction des erreurs deviennent plus précoces. Parmi les fonctionnalités clés de TypeScript, les Enums se distinguent. Un Enum, ou énumération, est une construction courante en TypeScript, contribuant à un code plus sûr.

Cet article a pour but de détailler les énumérations, leur création, leur usage, et d'autres points pertinents à considérer.

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

Enum est la forme abrégée de type énuméré. Un type de données énuméré est défini par l'ensemble des valeurs spécifiques qu'une variable de ce type peut accepter. Ces valeurs sont fréquemment désignées comme membres ou éléments.

Nous utiliserons le terme 'membres' dans cet article. Les énumérations ne sont pas une spécificité de TypeScript ; d'autres langages de programmation les intègrent également. L'utilisation des énumérations renforce la sécurité des types dans les applications TypeScript.

A lire également : Les principales bibliothèques et environnements d'exécution TypeScript incontournables pour les développeurs

Pourquoi recourir aux énumérations ?

Les énumérations vous permettent de préciser l'ensemble des valeurs admissibles pour une variable. Elles permettent aussi de contraindre les valeurs que peut prendre un argument de fonction. Ainsi, les développeurs sont assurés de fournir les valeurs attendues aux variables et aux arguments de fonction, réduisant les risques d'erreurs et garantissant un code plus fiable et robuste.

Prérequis pour manipuler les énumérations

Ce guide expliquera comment utiliser les énumérations dans TypeScript. Pour suivre ce tutoriel, vous devez pouvoir exécuter du code TypeScript.

Vous devez donc avoir installé Node.js pour pouvoir exécuter du code JavaScript. Si TypeScript n'est pas encore installé, la vidéo ci-dessous vous expliquera comment procéder.

Vous pouvez également utiliser ts-node pour compiler et exécuter vos scripts instantanément. Bien que ce soit la méthode utilisée ici, l'installation de TypeScript est préférable pour des projets plus conséquents. Pour exécuter un script avec ts-node, utilisez la commande suivante :

npx ts-node <nom_du_script>

Il est également supposé que vous avez des connaissances de base en JavaScript et TypeScript.

Manipulation d'une énumération simple

Création d'une énumération simple

En TypeScript, les énumérations sont créées à l'aide du mot-clé 'enum'. Il est suivi du nom de l'énumération, puis de la liste des membres qu'elle contient. Voici un exemple où nous définissons une énumération pour les quatre points cardinaux d'une boussole.

enum Direction {
    North,
    East,
    South,
    West
}

Notez que les membres de l'énumération ne sont pas entourés de guillemets ; ce ne sont pas des chaînes de caractères.

Utilisation d'une énumération simple

Voici comment attribuer une valeur énumérée à une variable :

const heading: Direction = Direction.North;

Comme la variable est initialisée au moment de sa déclaration, TypeScript peut déduire son type de données. Il n'est donc pas nécessaire d'indiquer son type explicitement. La déclaration peut être simplifiée de cette façon :

const heading = Direction.North;

Pour connaître la valeur de la variable 'heading', nous pouvons utiliser la console.

console.log(heading);

Le résultat sera :

La variable 'heading' prend la valeur zéro, malgré l'attribution de la valeur Direction.North. Ceci est dû au fait que chaque membre d'une énumération reçoit une valeur numérique lors de sa création. Le premier membre a la valeur 0, le deuxième 1, et ainsi de suite. En voici une démonstration :

console.log(Direction.North, Direction.East, Direction.South, Direction.West)

Il est donc possible de vérifier si la variable 'heading' représente le Nord en comparant sa valeur à zéro. Voici un exemple :

// Vérification de l'égalité
let isNorth = heading == 0;

// Affichage du résultat
console.log(isNorth);

Comme vu précédemment, Direction.North équivaut à 0. Plutôt que de vérifier si 'heading' est égal à zéro, il est préférable de vérifier si il est égal à Direction.North.

// Vérification de la direction
isNorth = heading == Direction.North;

// Affichage du résultat
console.log(isNorth);

Bien que cela soit utile, il existe des possibilités plus avancées, que nous allons explorer. La section suivante explique comment utiliser des valeurs personnalisées.

Utilisation de valeurs personnalisées

Lors de la création d'une énumération, TypeScript attribue automatiquement des valeurs numériques aux membres, en commençant par zéro. Cependant, il est possible de définir des valeurs personnalisées pour vos membres. Voici comment faire :

enum StarRating {
    VeryPoor = 1,
    Poor = 2,
    Average = 3,
    Good = 4,
    Excellent = 5
}

On peut également procéder de cette manière :

enum StarRating {
    VeryPoor = 1,
    Poor,
    Average,
    Good,
    Excellent
}

Dans ce cas, le premier membre prend la valeur 1. Les suivants sont automatiquement incrémentés par rapport à la valeur précédente. Ainsi, 'Poor' vaut 2, 'Average' vaut 3, et ainsi de suite.

Les membres d'une énumération ne sont pas toujours des valeurs numériques, comme nous allons le voir. Cependant, ceux qui possèdent des valeurs numériques se comportent comme des nombres ordinaires.

console.log(typeof StarRating.Average);

Cela affichera "number". Vous pouvez donc réaliser toutes les opérations numériques habituelles, y compris les comparaisons, telles que :

console.log(StarRating.Excellent > StarRating.Average)

Cela affichera "true".

Utilisation de chaînes comme valeurs personnalisées

Comme mentionné précédemment, les membres d'une énumération peuvent utiliser des chaînes de caractères au lieu de simples nombres. Voici comment procéder :

enum Choice {
    RedPill = "Know Everything"
    BluePill = "Know Nothing"
}

Dans ce cas, les membres d'énumération se comporteront comme précédemment. Cependant, comme leurs valeurs sont des chaînes de caractères, vous pouvez effectuer des opérations sur les chaînes et non sur les nombres, comme dans l'exemple précédent.

Énumérations hétérogènes

Il est aussi possible de mélanger les valeurs de chaîne et les valeurs numériques. Bien que cela soit déconseillé et peu utile, c'est néanmoins possible.

enum Mixed {
    First = "String"
    Second = 2
}

Conclusion

Cet article a présenté les énumérations dans TypeScript. Nous avons exploré leur utilité, ainsi que les différents types de valeurs que leurs membres peuvent avoir.

Consultez ensuite notre article sur Type vs. Interface dans TypeScript.