Vérification de la présence d'une valeur dans un Enum TypeScript : guide complet

Pourquoi vérifier une valeur dans un Enum TypeScript ? Exemple concret tiré de la pratique

Imaginez : vous écrivez un backend en Node.js avec TypeScript. Le client envoie un statut de commande — la chaîne "shipped". Vous avez un enum OrderStatus avec les variantes : Pending, Processing, Shipped, Delivered. Mais soudain, arrive "CANCELLED" ou "unknown". Que faire ? Exactement — vérifier si la valeur existe dans l'enum TypeScript.

Cette tâche est l'une des plus fréquentes sur Stack Overflow (des milliers de vues). Et pour cause : l'enum en TypeScript n'est pas qu'un simple ensemble de constantes, c'est une bête complexe avec des variantes numériques et textuelles. Dans ce guide, nous allons analyser toutes les méthodes pour vérifier la présence d'une valeur dans un enum, des plus simples aux plus avancées, avec des exemples de code et des explications.

Si vous débutez en TypeScript ou souhaitez approfondir vos connaissances, cet article est pour vous. C'est parti !

Qu'est-ce qu'un Enum en TypeScript ? Petit rappel

Un enum (énumération) est un moyen de définir un ensemble de constantes nommées. TypeScript propose deux types d'enum :

\n
• Enums numériques — les valeurs sont automatiquement incrémentées (0, 1, 2...).
\n
• Enums textuels — une chaîne est explicitement assignée à chaque membre.
\n

Exemple d'enum numérique :

enum Direction {\n    Up,    // 0\n    Down,  // 1\n    Left,  // 2\n    Right  // 3\n}

Exemple d'enum textuel :

enum Status {\n    Active = "ACTIVE",\n    Inactive = "INACTIVE",\n    Pending = "PENDING"\n}

Pourquoi vérifier une valeur ? Parce que les données externes (API, formulaires, bases de données) peuvent être quelconques. Sans vérification, vous risquez d'obtenir undefined ou une erreur d'exécution.

Méthode 1. La classique : Object.values() + includes()

La méthode la plus populaire et lisible consiste à transformer l'enum en tableau de valeurs et à vérifier l'appartenance avec includes().

Pour les enums textuels :

enum Color {\n    Red = "RED",\n    Green = "GREEN",\n    Blue = "BLUE"\n}\n\nfunction isColor(value: string): boolean {\n    return Object.values(Color).includes(value as Color);\n}\n\nconsole.log(isColor("RED"));    // true\nconsole.log(isColor("YELLOW")); // false

Pour les enums numériques — une astuce ! Object.values() retourne un mappage inversé (clés et valeurs). Il faut donc filtrer uniquement les nombres :

enum NumberEnum {\n    A = 1,\n    B = 2,\n    C = 3\n}\n\nfunction isNumberEnumValue(value: number): boolean {\n    return Object.values(NumberEnum).filter(v => typeof v === 'number').includes(value);\n}\n\nconsole.log(isNumberEnumValue(2)); // true\nconsole.log(isNumberEnumValue(5)); // false

Cette approche est universelle, mais nécessite de la prudence avec les enums numériques. Avantage : simple et claire. Inconvénient : il faut penser au filtrage.

Méthode 2. Type Guard : vérification via les clés de l'enum

Si vous avez besoin non seulement de vérifier la valeur, mais aussi d'obtenir une garantie de type, utilisez un type guard. Cette méthode est particulièrement utile lors du travail avec des API, où vous souhaitez affiner le type.

enum UserRole {\n    Admin = "admin",\n    User = "user",\n    Guest = "guest"\n}\n\nfunction isUserRole(value: string): value is UserRole {\n    return Object.values(UserRole).includes(value as UserRole);\n}\n\nfunction processRole(role: string) {\n    if (isUserRole(role)) {\n        // TypeScript sait que role est de type UserRole\n        console.log(`Rôle : ${role}`);\n    } else {\n        console.log("Rôle inconnu");\n    }\n}\n\nprocessRole("admin"); // Rôle : admin\nprocessRole("moderator"); // Rôle inconnu

Cette approche offre la sécurité des types et réduit le nombre de vérifications dans le code. Je la recommande pour les projets sérieux.

Méthode 3. Helper personnalisé