Cómo usar enumeraciones en TypeScript

Una enumeración, o un tipo enumerado, es una estructura de datos que le permite definir un conjunto de valores con nombre.

Las enumeraciones proporcionan una forma de representar un conjunto fijo de valores como constantes. Pueden ayudar a que su código sea más expresivo y autodocumentado al dar nombres significativos a valores específicos. Aquí aprenderá cómo puede usar enumeraciones en TypeScript.

Crear una enumeración

Las enumeraciones generalmente representan un número fijo de opciones para un valor dado. Por ejemplo, una enumeración que represente colores primarios podría tener valores fijos para rojo, amarillo y azul.

Las enumeraciones representan datos como un conjunto de pares clave/valor conocidos como miembros de la enumeración. La clave siempre debe ser una cadena. Sin embargo, el valor, un número de incremento automático predeterminado, puede ser numérico, una cadena o calculado.

Puede crear una enumeración en el lenguaje mecanografiado utilizando el enumeración palabra clave. Sígalo con el nombre de la enumeración y un par de llaves ({}) que contiene los miembros de la enumeración. Una convención común de nomenclatura de JavaScript establece que los nombres de enumeración deben comenzar con una letra mayúscula.

enumeración Dirección {
 Arriba,
 Abajo,
 Izquierda,
 Bien
}

Este ejemplo presenta una enumeración llamada Dirección. La enumeración tiene un miembro que representa cada dirección: Arriba, Abajo, Izquierda y Derecha.

Dado que este código no especifica un valor para cada una de las claves, TypeScript asignará valores automáticamente. El primer miembro, Up, tendrá un valor de 0. Los miembros restantes tendrán cada uno un valor 1 mayor que el del miembro anterior. Puede declarar esto explícitamente si le resulta difícil recordarlo:

enumeración Dirección {
 Arriba = 0,
 Abajo = 1,
 Izquierda = 2,
 Derecha = 3,
}

O puede declarar explícitamente diferentes valores, dejando valores no declarados para continuar incrementándose como antes:

enumeración Estado {
 Activo = 9,
 Inactivo, // 10
}

En este ejemplo, el miembro Inactivo tiene un valor de 10. Este comportamiento se aplica a las enumeraciones que solo tienen valores numéricos, no a las que tienen cadenas o miembros heterogéneos.

Los diferentes tipos de enumeración

Las enumeraciones en TypeScript tienen un tipo implícito que se basan en el tipo de valores que tienen sus miembros. El tipo más común es la enumeración numérica, cuyo comportamiento cubre la sección anterior, pero hay dos variaciones.

Enumeraciones de cadena

Una enumeración de cadena es una enumeración en la que todos sus miembros son cadenas. A diferencia de las enumeraciones numéricas, donde los valores se asignan automáticamente, debe inicializar cada miembro con una cadena:

enumeración Colores primarios {
 rojo = "ROJO",
 amarillo = "AMARILLO",
 azul = "AZUL"
}

Aunque las enumeraciones de cadenas no tienen propiedades de incremento automático, pueden tener más sentido si las serializa. Sus valores deben seguir siendo descriptivos, sin nombres de miembros, mientras que un conjunto de valores numéricos puede no ser autodescriptivo.

Enumeraciones heterogéneas

Las enumeraciones heterogéneas son enumeraciones que contienen miembros numéricos y de cadena. Por ejemplo:

enumeración Resultado {
 Éxito = "ÉXITO",
 Fracaso = 0
}

Las enumeraciones heterogéneas son útiles cuando tiene miembros de enumeración que requieren diferentes tipos de valores según el contexto o significado específico de cada miembro. sin embargo, el Documentación de mecanografiado desaconseja el uso de enumeraciones heterogéneas, ya que introducen una complejidad que puede hacer que su código sea más propenso a errores.

Miembros de enumeración calculados y constantes

Cada miembro de enumeración tiene un valor, que puede ser constante o calculado.

Miembros de enumeración constante

Un miembro de enumeración es constante si cumple alguna de las condiciones siguientes.

1. Es el primer miembro de la enumeración y no tiene inicializador.
2. No tiene un inicializador y el miembro de enumeración anterior era una constante numérica.
3. Se inicializa con una expresión de enumeración constante.

De acuerdo con la documentación de TypeScript, una expresión de enumeración constante es un subconjunto de expresiones de TypeScript que se pueden evaluar completamente en tiempo de compilación. Por ejemplo, una cadena o un literal numérico.

Por ejemplo, los miembros de las enumeraciones en el bloque de código a continuación son todos constantes:

// CASO 1
enumeración Dirección {
 Arriba,
 Abajo,
 Izquierda,
 Bien
}
// CASO 2
enumeración Día laborable {
 lunes = 1,
 Martes,
 Miércoles,
 Jueves,
 Viernes
}
// CASO 3
enumeración Estación {
 Primavera = "PRIMAVERA",
 Verano = "VERANO",
 Otoño = "OTOÑO",
 Invierno = "INVIERNO"
}

Cuando transpila miembros de enumeración constantes en JavaScript simple, el código generado usa sus valores literales. Esto puede ser beneficioso para el rendimiento y facilitar la depuración.

Por ejemplo, aquí está la versión transpilada de la enumeración Season:

variable Estación;
(función (Estación) {
 Estación["Primavera"] = "PRIMAVERA";
 Estación["Verano"] = "VERANO";
 Estación["Otoño"] = "OTOÑO";
 Estación["Invierno"] = "INVIERNO";
})(Temporada || (Temporada = {}));

Miembros de enumeración calculados

Puede usar miembros de enumeración calculados para asignar valores a miembros de enumeración en función de expresiones u otros cálculos dinámicos. Por ejemplo:

enumeración Tamaño {
 pequeño = 1,
 Medio = calcularTamaño(12),
 Grande = calcularTamaño(5)
}
funcióncalcularTamaño(valor: número): número{
devolver valor * 5;
}
consola.log (Tamaño. Grande)

El Tamaño enum tiene tres miembros: Pequeño, Medio, y Grande. Asigna explícitamente el valor 1 al miembro Small. El Medio y Grande los miembros usan una función calcularTamaño para calcular sus valores en tiempo de ejecución.

Cuando se trabaja con miembros de enumeración calculados, es importante tener en cuenta que los valores no se conocen hasta el tiempo de ejecución. Esto puede introducir más complejidad y potencial errores de ejecución en comparación con los miembros de enumeración con valores constantes.

Por ejemplo:

variable Tamaño;
(función (Tamaño) {
 Tamaño[Tamaño["Pequeño"] = 1] = "Pequeño";
 Tamaño[Tamaño["Medio"] = calcularTamaño(12)] = "Medio";
 Tamaño[Tamaño["Grande"] = calcularTamaño(5)] = "Grande";
})(Tamaño || (Tamaño = {}));
consola.registro(Tamaño.Grande)

El bloque de código anterior es la versión transpilada del Tamaño enumeración Observe cómo TypeScript no incluye los valores devueltos de computeSize() en el código JavaScript. En su lugar, incluye la llamada de función original para que JavaScript determine los valores en tiempo de ejecución.

Acceso a valores de enumeración

Puede acceder a los valores de los miembros de la enumeración mediante la notación de punto de objeto.

Por ejemplo:

enumeración Dirección {
 Arriba = 0,
 Abajo = 1,
 Izquierda = 2,
 Derecha = 3,
}
consola.log (Dirección. Izquierda) // 2

Enumeraciones numéricas de mapeo inverso

El mapeo inverso en enumeraciones numéricas se refiere a la capacidad de obtener el nombre de miembro de enumeración correspondiente a partir de su valor. Esto puede ser particularmente útil cuando se trabaja con valores numéricos, que es posible que deba decodificar.

De forma predeterminada, los valores de enumeración en TypeScript se asignan hacia adelante, lo que significa que solo puede acceder al valor asociado con un nombre. Sin embargo, puede realizar manualmente la asignación inversa para recuperar el miembro de la enumeración en función de su valor.

Por ejemplo:

enumeración Dirección {
 Arriba = 1,
 Abajo,
 Izquierda,
 Bien
}
funcióngetDirectionName(valor de dirección: número): cadena{
// mapeo inverso
constante nombreDirección = Dirección[ValorDirección];
devolver direcciónNombre;
}
consola.log (obtenerNombreDirección(1)); // "Arriba"
consola.log (obtenerNombreDirección(3)); // "Izquierda"

Este getDirectionName La función realiza el mapeo inverso al acceder al nombre del miembro de la enumeración usando su valor como índice. La función toma un valor de dirección como un argumento y recupera el nombre del miembro de enumeración correspondiente usando Dirección[valorDirección].

El mapeo inverso puede ser útil en escenarios en los que tiene un valor numérico y necesita determinar el nombre del miembro de enumeración correspondiente. Proporciona una manera conveniente de trabajar con enumeraciones tanto en dirección directa como inversa.

Hay muchas aplicaciones de enumeraciones

Puede usar enumeraciones en varios escenarios, como el manejo de instrucciones de cambio, la definición de parámetros de funciones, la asignación de datos y la representación de opciones o configuraciones.

Ya sea que necesite representar un conjunto finito de opciones o administrar transiciones de estado complejas, las enumeraciones en TypeScript son una herramienta valiosa para mejorar la claridad y la estructura de su código.