Alternativas a los Enum de TypeScript: Afirmaciones Const vs. Tipos Union

enum de TypeScript es una característica poderosa para definir un conjunto de constantes con nombre. Sin embargo, no siempre es la mejor opción. Este artículo explora alternativas a los enum, específicamente afirmaciones const y tipos union, y proporciona orientación sobre cuándo usar cada uno para una calidad, mantenibilidad y rendimiento óptimos del código. Profundizaremos en los matices de cada enfoque, ofreciendo ejemplos prácticos y abordando inquietudes comunes.

Comprendiendo los Enum de TypeScript

Antes de sumergirnos en las alternativas, revisemos rápidamente los enum de TypeScript. Un enum es una forma de definir un conjunto de constantes numéricas con nombre. Por defecto, al primer miembro del enum se le asigna el valor 0, y los miembros subsiguientes se incrementan en 1.

            
enum Status {
  Pending,
  InProgress,
  Completed,
  Rejected,
}

const currentStatus: Status = Status.InProgress; // currentStatus será 1

            

              
                Copy
              
            
          

También puedes asignar explícitamente valores a los miembros del enum:

            
enum HTTPStatus {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  Forbidden = 403,
  NotFound = 404,
}

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse será 200

            

              
                Copy
              
            
          

Beneficios de los Enum

• Legibilidad: Los enum mejoran la legibilidad del código al proporcionar nombres significativos para las constantes numéricas.
• Seguridad de tipos: Refuerzan la seguridad de tipos al restringir los valores a los miembros del enum definidos.
• Autocompletado: Los IDE proporcionan sugerencias de autocompletado para los miembros del enum, reduciendo errores.

Desventajas de los Enum

• Sobrecarga en tiempo de ejecución: Los enum se compilan en objetos de JavaScript, lo que puede introducir sobrecarga en tiempo de ejecución, especialmente en aplicaciones grandes.
• Mutación: Los enum son mutables por defecto. Si bien TypeScript proporciona const enum para prevenir la mutación, tiene limitaciones.
• Mapeo inverso: Los enum numéricos crean un mapeo inverso (por ejemplo, Status[1] devuelve "InProgress"), lo cual a menudo es innecesario y puede aumentar el tamaño del paquete.

Alternativa 1: Afirmaciones Const

Las afirmaciones const proporcionan una forma de crear estructuras de datos inmutables y de solo lectura. Se pueden usar como una alternativa a los enum en muchos casos, especialmente cuando necesitas un conjunto simple de constantes de cadena o numéricas.

            
const Status = {
  Pending: 'pending',
  InProgress: 'in_progress',
  Completed: 'completed',
  Rejected: 'rejected',
} as const;

// Typescript infiere el siguiente tipo:
// {
//    readonly Pending: "pending";
//    readonly InProgress: "in_progress";
//    readonly Completed: "completed";
//    readonly Rejected: "rejected";
// }

type StatusType = typeof Status[keyof typeof Status]; // 'pending' | 'in_progress' | 'completed' | 'rejected'

function processStatus(status: StatusType) {
  console.log(`Processing status: ${status}`);
}

processStatus(Status.InProgress); // Válido
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'StatusType'.

            

              
                Copy
              
            
          

En este ejemplo, definimos un objeto plano de JavaScript con valores de cadena. La afirmación as const le dice a TypeScript que trate este objeto como de solo lectura e infiera los tipos más específicos para sus propiedades. Luego extraemos un tipo union de las claves. Este enfoque ofrece varias ventajas:

Beneficios de las Afirmaciones Const

• Inmutabilidad: Las afirmaciones const crean estructuras de datos inmutables, previniendo modificaciones accidentales.
• Sin sobrecarga en tiempo de ejecución: Son objetos simples de JavaScript, por lo que no hay sobrecarga en tiempo de ejecución asociada con los enum.
• Seguridad de tipos: Proporcionan una fuerte seguridad de tipos al restringir los valores a las constantes definidas.
• Amigable con el tree-shaking: Los bundlers modernos pueden fácilmente eliminar los valores no utilizados, reduciendo el tamaño del paquete.

Consideraciones para las Afirmaciones Const

• Más verboso: Definir y tipar puede ser ligeramente más verboso que los enum, especialmente para casos simples.
• Sin mapeo inverso: No proporcionan mapeo inverso, pero esto a menudo es un beneficio en lugar de una desventaja.

Alternativa 2: Tipos Union

Los tipos union te permiten definir una variable que puede contener uno de varios tipos posibles. Son una forma más directa de definir los valores permitidos sin un objeto, lo cual es beneficioso cuando no necesitas la relación clave-valor de un enum o una afirmación const.

            
type Status = 'pending' | 'in_progress' | 'completed' | 'rejected';

function processStatus(status: Status) {
  console.log(`Processing status: ${status}`);
}

processStatus('in_progress'); // Válido
// processStatus('invalid'); // Error: Argument of type '"invalid"' is not assignable to parameter of type 'Status'.

            

              
                Copy
              
            
          

Esta es una forma concisa y segura de tipos de definir un conjunto de valores permitidos.

Beneficios de los Tipos Union

• Concisión: Los tipos union son el enfoque más conciso, especialmente para conjuntos simples de constantes de cadena o numéricas.
• Seguridad de tipos: Proporcionan una fuerte seguridad de tipos al restringir los valores a las opciones definidas.
• Sin sobrecarga en tiempo de ejecución: Los tipos union existen solo en tiempo de compilación y no tienen representación en tiempo de ejecución.

Consideraciones para los Tipos Union

• Sin asociación clave-valor: No proporcionan una relación clave-valor como los enum o las afirmaciones const. Esto significa que no puedes buscar fácilmente un valor por su nombre.
• Repetición de literales de cadena: Es posible que debas repetir literales de cadena si usas el mismo conjunto de valores en varios lugares. Esto se puede mitigar con una definición de type compartida.

¿Cuándo usar cuál?

El mejor enfoque depende de tus necesidades y prioridades específicas. Aquí tienes una guía para ayudarte a elegir:

• Usar Enum Cuando:
  • Necesitas un conjunto simple de constantes numéricas con incremento implícito.
  • Necesitas mapeo inverso (aunque esto rara vez es necesario).
  • Estás trabajando con código heredado que ya usa enum extensivamente y no tienes una necesidad apremiante de cambiarlo.
• Usar Afirmaciones Const Cuando:
  • Necesitas un conjunto de constantes de cadena o numéricas que deben ser inmutables.
  • Necesitas una relación clave-valor y quieres evitar la sobrecarga en tiempo de ejecución.
  • El tree-shaking y el tamaño del paquete son consideraciones importantes.
• Usar Tipos Union Cuando:
  • Necesitas una forma simple y concisa de definir un conjunto de valores permitidos.
  • No necesitas una relación clave-valor.
  • El rendimiento y el tamaño del paquete son críticos.

Escenario de Ejemplo: Definiendo Roles de Usuario

Consideremos un escenario donde necesitas definir roles de usuario en una aplicación. Podrías tener roles como "Admin", "Editor" y "Viewer".

Usando Enums:

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Usando Afirmaciones Const:

            
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

function authorize(role: UserRoleType) {
  // ...
}

            

              
                Copy
              
            
          

Usando Tipos Union:

            
type UserRole = 'admin' | 'editor' | 'viewer';

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

En este escenario, los tipos union ofrecen la solución más concisa y eficiente. Las afirmaciones const son una buena alternativa si prefieres una relación clave-valor, quizás para buscar descripciones de cada rol. Generalmente no se recomiendan los enum aquí a menos que tengas una necesidad específica de valores numéricos o mapeo inverso.

Escenario de Ejemplo: Definiendo Códigos de Estado de Puntos de Acceso API

Consideremos un escenario donde necesitas definir códigos de estado de puntos de acceso API. Podrías tener códigos como 200 (OK), 400 (Bad Request), 401 (Unauthorized) y 500 (Internal Server Error).

Usando Enums:

            
enum StatusCode {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  InternalServerError = 500
}

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Usando Afirmaciones Const:

            
const StatusCode = {
  OK: 200,
  BadRequest: 400,
  Unauthorized: 401,
  InternalServerError: 500
} as const;

type StatusCodeType = typeof StatusCode[keyof typeof StatusCode];

function processStatus(code: StatusCodeType) {
  // ...
}

            

              
                Copy
              
            
          

Usando Tipos Union:

            
type StatusCode = 200 | 400 | 401 | 500;

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

De nuevo, los tipos union ofrecen la solución más concisa y eficiente. Las afirmaciones const son una alternativa sólida y pueden ser preferibles ya que proporcionan una descripción más detallada para un código de estado dado. Los enum podrían ser útiles si las bibliotecas o API externas esperan códigos de estado basados en enteros, y quieres asegurar una integración perfecta. Los valores numéricos se alinean con los códigos HTTP estándar, potencialmente simplificando la interacción con los sistemas existentes.

Consideraciones de Rendimiento

En la mayoría de los casos, la diferencia de rendimiento entre los enum, las afirmaciones const y los tipos union es insignificante. Sin embargo, en aplicaciones críticas para el rendimiento, es importante ser consciente de las posibles diferencias.

• Enums: Los enum introducen sobrecarga en tiempo de ejecución debido a la creación de objetos de JavaScript. Esta sobrecarga puede ser significativa en aplicaciones grandes con muchos enum.
• Afirmaciones Const: Las afirmaciones const no tienen sobrecarga en tiempo de ejecución. Son objetos simples de JavaScript que TypeScript trata como de solo lectura.
• Tipos Union: Los tipos union no tienen sobrecarga en tiempo de ejecución. Existen solo en tiempo de compilación y se borran durante la compilación.

Si el rendimiento es una preocupación importante, los tipos union son generalmente la mejor opción. Las afirmaciones const también son una buena opción, especialmente si necesitas una relación clave-valor. Evita usar enum en secciones del código críticas para el rendimiento a menos que tengas una razón específica para hacerlo.

Implicaciones Globales y Mejores Prácticas

Cuando se trabaja en proyectos con equipos internacionales o usuarios globales, es crucial considerar la localización e internacionalización. Aquí hay algunas mejores prácticas para usar enum y sus alternativas en un contexto global:

• Usar nombres descriptivos: Elige nombres de miembros de enum (o claves de afirmación const) que sean claros e inequívocos, incluso para hablantes no nativos de inglés. Evita la jerga o el argot.
• Considerar la localización: Si necesitas mostrar nombres de miembros de enum a los usuarios, considera usar una biblioteca de localización para proporcionar traducciones para diferentes idiomas. Por ejemplo, en lugar de mostrar directamente Status.InProgress, podrías mostrar i18n.t('status.in_progress').
• Evitar suposiciones específicas de la cultura: Ten en cuenta las diferencias culturales al definir valores de enum. Por ejemplo, los formatos de fecha, los símbolos de moneda y las unidades de medida pueden variar significativamente entre culturas. Si necesitas representar estos valores, considera usar una biblioteca que maneje la localización e internacionalización.
• Documentar tu código: Proporciona documentación clara y concisa para tus enum y sus alternativas, explicando su propósito y uso. Esto ayudará a otros desarrolladores a comprender tu código, independientemente de sus antecedentes o experiencia.

Ejemplo: Localizando Roles de Usuario

Revisitemos el ejemplo de roles de usuario y consideremos cómo localizar los nombres de los roles para diferentes idiomas.

            
// Usando Afirmaciones Const con Localización
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Función de localización (usando una hipotética biblioteca i18n)
function getLocalizedRoleName(role: UserRoleType, locale: string): string {
  switch (role) {
    case UserRole.Admin:
      return i18n.t('user_role.admin', { locale });
    case UserRole.Editor:
      return i18n.t('user_role.editor', { locale });
    case UserRole.Viewer:
      return i18n.t('user_role.viewer', { locale });
    default:
      return 'Rol Desconocido';
  }
}

// Ejemplo de uso
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Devuelve "Éditeur" localizado para francés canadiense.
console.log(`Rol actual: ${localizedRoleName}`);

            

              
                Copy
              
            
          

En este ejemplo, usamos una función de localización para recuperar el nombre del rol traducido según la configuración regional del usuario. Esto asegura que los nombres de los roles se muestren en el idioma preferido del usuario.

Conclusión

Los enum de TypeScript son una característica útil, pero no siempre son la mejor opción. Las afirmaciones const y los tipos union ofrecen alternativas viables que pueden proporcionar un mejor rendimiento, inmutabilidad y mantenibilidad del código. Al comprender los beneficios y las desventajas de cada enfoque, puedes tomar decisiones informadas sobre cuál usar en tus proyectos. Considera las necesidades específicas de tu aplicación, las preferencias de tu equipo y la mantenibilidad a largo plazo de tu código. Al sopesar cuidadosamente estos factores, puedes elegir el mejor enfoque para definir constantes en tus proyectos de TypeScript, lo que lleva a bases de código más limpias, eficientes y fáciles de mantener.