Verificación de existencia de un valor en Enum TypeScript: guía completa

¿Por qué verificar un valor en Enum TypeScript? Ejemplo práctico real

Imagine: está escribiendo un backend en Node.js con TypeScript. El cliente envía el estado de un pedido — una cadena "shipped". Usted tiene un enum OrderStatus con las opciones: Pending, Processing, Shipped, Delivered. Pero de repente llega "CANCELLED" o "unknown". ¿Qué hacer? Correcto — verificar si el valor existe en el enum de TypeScript.

Esta tarea es una de las más comunes en Stack Overflow (miles de visitas). Y con razón: el enum en TypeScript no es solo un conjunto de constantes, sino una bestia astuta con variantes numéricas y de cadena. En esta guía analizaremos todas las formas de verificar la presencia de un valor en un enum, desde las simples hasta las avanzadas, con ejemplos de código y explicaciones.

Si recién está comenzando a aprender TypeScript o desea profundizar sus conocimientos, este artículo es para usted. ¡Vamos allá!

¿Qué es un Enum en TypeScript? Breve introducción

Un Enum (enumeración) es una forma de definir un conjunto de constantes con nombre. En TypeScript existen dos tipos de enum:

\n
• Enums numéricos — los valores se incrementan automáticamente (0, 1, 2...).
\n
• Enums de cadena — a cada miembro se le asigna explícitamente una cadena.
\n

Ejemplo de enum numérico:

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

Ejemplo de enum de cadena:

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

¿Por qué verificar un valor? Porque los datos externos (API, formularios, bases de datos) pueden ser cualquier cosa. Sin verificación, corre el riesgo de obtener undefined o un error en tiempo de ejecución.

Método 1. El clásico: Object.values() + includes()

La forma más popular y legible es convertir el enum en un array de valores y verificar la pertenencia con includes().

Para enums de cadena:

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

Para enums numéricos — ¡un truco! Object.values() devuelve un mapeo inverso (claves y valores). Por lo tanto, es necesario filtrar solo los números:

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

Este enfoque es universal, pero requiere cuidado con los enums numéricos. Ventaja: simple y claro. Desventaja: hay que recordar el filtrado.

Método 2. Type Guard: verificación a través de las claves del enum

Si no solo necesita verificar un valor, sino también obtener una garantía de tipo, use un type guard. Este método es especialmente útil al trabajar con API, donde desea restringir el tipo.

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 sabe que role es UserRole\n        console.log(`Rol: ${role}`);\n    } else {\n        console.log("Rol desconocido");\n    }\n}\n\nprocessRole("admin"); // Rol: admin\nprocessRole("moderator"); // Rol desconocido

Este enfoque proporciona seguridad de tipos y reduce la cantidad de verificaciones en el código. Lo recomiendo para proyectos serios.

Método 3. Helper personalizado