Comment geler une énumération en JavaScript sans perdre la raison

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi votre énumération peut « fuiter » et comment l'éviter

Imaginez que vous travaillez sur un grand projet en JavaScript. Vous avez créé une énumération pour les statuts de commande : PENDING, SHIPPED, DELIVERED. Tout fonctionne parfaitement, jusqu'à ce que, dans l'un des modules, un développeur (ou vous-même six mois plus tard) écrive accidentellement : OrderStatus.PENDING = 'CANCELLED'. Ou, pire encore, Object.assign(OrderStatus, { NEW_STATUS: 'hacked' }). Boum ! La logique de l'application se casse, le bug part en production, et vous passez une nuit blanche à déboguer.

C'est un problème classique qui a rassemblé des milliers de vues sur Stack Overflow. La question « How can I guarantee that my enums definition doesn't change in JavaScript? » tourmente beaucoup de monde. Et ce n'est pas sans raison : JavaScript est un langage dynamique, et ses objets sont mutables par défaut. Mais il existe des solutions, et aujourd'hui nous allons passer en revue toutes les méthodes fiables pour protéger vos énumérations.

Dans cet article, je vais vous montrer plusieurs approches éprouvées : du simple Object.freeze() aux techniques avancées avec Symbol et TypeScript. Vous apprendrez à écrire des énumérations immuables qui résisteront à toute modification accidentelle (ou non).

Le problème : pourquoi une énumération en JavaScript n'est qu'un objet

Contrairement à certains langages (C#, Java, Rust), JavaScript ne possède pas de construction native enum. Les développeurs les émulent à l'aide de simples objets :

const OrderStatus = {  PENDING: 'pending',  SHIPPED: 'shipped',  DELIVERED: 'delivered'};

Cela fonctionne, mais cette émulation a un défaut fatal : n'importe qui peut modifier la valeur. Et ce n'est pas seulement une question de mauvaise intention — cela arrive souvent accidentellement :

Affectation accidentelle dans une boucle ou un callback.
Immuabilité ? On oublie — et quelqu'un étend l'objet.
Bibliothèques qui peuvent muter les objets qui leur sont passés.

Le problème est aggravé par le fait que, dans les grandes bases de code, il est difficile de suivre ces modifications. C'est pourquoi la question de la protection des énumérations contre les modifications est si populaire.

Solution n°1 : Object.freeze() — votre premier bouclier

La méthode la plus simple et la plus courante consiste à utiliser Object.freeze(). Cette méthode rend un objet immuable : vous ne pouvez pas ajouter, supprimer ou modifier ses propriétés.

Comment ça fonctionne

const OrderStatus = Object.freeze({  PENDING: 'pending',  SHIPPED: 'shipped',  DELIVERED: 'delivered'});

// Tentative de modification — ne fonctionnera pasOrderStatus.PENDING = 'CANCELLED'; // Silence (en mode strict — erreur)OrderStatus.NEW = 'new';           // Ne s'ajoutera pasdelete OrderStatus.SHIPPED;       // Ne se supprimera pas

console.log(OrderStatus.PENDING); // 'pending' — la valeur n'a pas changé

Pourquoi est-ce utile ? Object.freeze() agit au niveau de l'objet lui-même. C'est un mécanisme intégré qui ne nécessite pas de bibliothèques supplémentaires. Il est parfait pour protéger les énumérations en JavaScript contre les mutations accidentelles.

Limitations de Object.freeze()

Gel superficiel — si les valeurs de l'énumération sont des objets, elles restent mutables.
Ne protège pas contre la réaffectation — si vous utilisez let au lieu de const, la variable peut être entièrement réécrite.
Ne génère pas d'erreurs en mode non strict — les modifications sont simplement ignorées, ce qui peut masquer un bug.

Mais pour les énumérations simples, cela est plus que suffisant. Si vous avez besoin d'une protection supplémentaire, lisez la suite.