Enums

Diferencias entre enum y literal types:
Investigando un poco entre algunas diferencias que me gustaría compartirles:

• ** Asignación de valores, por ejemplo los parámetros de una función:**

enum Estaciones {
  primavera = "Primavera",
  verano = "Verano",
  otonio = "Otoño",
  invierno = "Invierno",
}

const favEstacion = (est: Estaciones): string => {
  return `Mi estación fav es: ${est}`;
};
console.log(favEstacion("verano")); //❌ no se puede mandar un string suelto
console.log(favEstacion(Estaciones.verano)); //✅tenemos que ser mas especificos

Con un enum tenemos que ser mas específicos al momento de llamar a sus valores, no podemos acceder a ellos como si fuera una simple cadena.

Mientras que con un literal type esto es mucho mas sencillo:

type Estaciones = "Primavera" | "Verano" | "Otoño" | "Invierno";

const favEstacion = (est: Estaciones): string => {
  return `Mi estación fav es: ${est}`;
};
console.log(favEstacion("Primavera")); // ✅ Podemos usar los argumentos como si fuera js nativo

• **Código compilado: **
  Con literal types el código compilado es mas sencillo:

"use strict";
const favEstacion = (est) => {
    return `Mi estación fav es: ${est}`;
};
console.log(favEstacion("Primavera")); // ✅ Podemos usar los argumentos como si fuera js nativo

Mientras que con enums el código resultante es mas complejo y verboso:

"use strict";
var Estaciones;
(function (Estaciones) {
    Estaciones["primavera"] = "Primavera";
    Estaciones["verano"] = "Verano";
    Estaciones["otonio"] = "Oto\u00F1o";
    Estaciones["invierno"] = "Invierno";
})(Estaciones || (Estaciones = {}));
const favEstacion = (est) => {
    return `Mi estación fav es: ${est}`;
};
console.log(favEstacion(Estaciones.primavera)); // ✅ Podemos usar los argumentos como si fuera js nativo

Enums

Los enums funcionan como listas en las que podemos agregar llaves y valores. Esto lo que nos permite es tener un set de opciones predefinidas, evitando pasar un argumento invalido, ya que solo vamos a tener las opciones dentro del enum. Estos se usan de la siguiente manera

enum ROLES {
  ADMIN = "admin",
  USER = "user",
  OWNER = "owner"
}

Se recomiendo nombrar al enum en mayúscula.

Personalmente he usado los enums como una alternativa a crear un archivo constants.js.

En este caso en particular lo usé para los action types de Redux.

enum SearchActionTypes {
  SET_RECOVER_PRODUCTS = 'SEARCH/SET_RECOVER_PRODUCTS',
  SET_LOADING = 'SEARCH/SET_LOADING',
  SET_ALGOLIA_MARKETPLACE = 'SEARCH/SET_ALGOLIA_MARKETPLACE',
  SET_ALGOLIA_STORE = 'SEARCH/SET_ALGOLIA_STORE',
} 

😄 Hola! Lei algo super importante en la documentacion que se que nos va a servir a todos!
Hay Enums numericos y String-based. Los String-based son los que explico el profe pero los numericos tienen algunas cosas que considero importante que lean ya que estos pueden ser inizializados o no. Si no se inicializan El primer valor siempre toma el valor numérico de 0, mientras que los demás valores de la enumeración se incrementan en 1. Pero si se inicializan incrementan segun el numero que se haya puesto. Para que tengan mas contexto sobre el tema dejo estos dos links que explican muy bien como se manejan los enums:
https://www.typescriptlang.org/docs/handbook/enums.html
https://www.tutorialsteacher.com/typescript/typescript-enum

Un uso para los enums que he visto que usan algunos “youtubeDevs” es para el uso de condicionales switch y evitar typos en los “cases” y, su consecuente asignación a la variable a evaluar.

Otras características de enum

Si en un enum las keys solo se declaran y no se inicializan con valores, estas se inician automáticamente por defecto en orden númerico, empezando por el 0 y auto incrementandose.

enum ENUM_NUMBER {
  X,Y,Z
}

console.log(ENUM_NUMBER.X) // 0
console.log(ENUM_NUMBER.Y) // 1
console.log(ENUM_NUMBER.Z) // 2

También es posible inicializar manualmente una key y sus atributos se incrementaran a partir de este valor

enum ENUM_NUMBER {
  X = 1,
  Y,
  Z
}

console.log(ENUM_NUMBER.X) // 1
console.log(ENUM_NUMBER.Y) // 2
console.log(ENUM_NUMBER.Z) // 3

Recomiendo la documentación por si tienen dudas sobre enums. Además, dentro de la documentación se menciona sobre enums de tipo string y number, además, de que no recomienda mezclarlos dentro de un enum.

alias ts= touch $*{.ts}

ts 01-enum

asi que esto son los enums, no lo sabia y lo vi muchas veces cuando tenia error en algun programa y aparecia algo similar a enums con mayusculas. Y si no me equivoco configurando algunas extensiones de vscode

éste profe es excelente …

Lo que me dijo ChatGPT:

En TypeScript, un enum es una estructura de datos que permite definir un conjunto de constantes con nombre. Un enum es una forma de crear un tipo de dato personalizado, que contiene un conjunto de valores que pueden ser utilizados en lugar de números o cadenas de caracteres.

Para definir un enum en TypeScript, se utiliza la palabra clave enum, seguida del nombre del enum y una lista de valores separados por comas. Por ejemplo:

enum Direccion {   
    Arriba = "ARRIBA",   
    bajo = "ABAJO",   
    Izquierda = "IZQUIERDA",   
    Derecha = "DERECHA" 
}

En este ejemplo, hemos definido un enum llamado Direccion que contiene cuatro valores: Arriba, Abajo, Izquierda y Derecha. Cada valor está asociado con una cadena de caracteres que representa su nombre.

Los enums en TypeScript también tienen la opción de asignar valores numéricos automáticamente a cada valor en el enum. Por defecto, el primer valor en el enum se establece en 0 y los siguientes valores se incrementan en 1, pero es posible cambiar este comportamiento utilizando el operador = para asignar valores numéricos específicos a cada elemento. Por ejemplo:

enum DiaSemana {
   Lunes,
   Martes,
   Miercoles = 10,
   Jueves,
   Viernes 
}

En este ejemplo, el enum DiaSemana tiene cinco valores, siendo el segundo (Martes) el número 1 y el cuarto (Jueves) el número 11.

Una vez definido un enum, se pueden utilizar sus valores en cualquier parte del código donde se necesite utilizar una constante con nombre. Por ejemplo:

let direccionActual: Direccion = Direccion.Arriba; 

if (direccionActual === Direccion.Abajo) {
   // hacer algo 
}

En este ejemplo, se declara una variable direccionActual de tipo Direccion y se le asigna el valor Direccion.Arriba. Luego, se utiliza un if para verificar si direccionActual es igual al valor Direccion.Abajo. Como se puede ver, esto hace que el código sea más legible y fácil de entender que si se utilizara un número o una cadena de caracteres directamente.

Acá traigo un video acerca de los enums para ayudar a clarificar este concepto tan importante https://www.youtube.com/watch?v=r8G7-hQG07o , espero sea de ayuda.

Probablemente no sea tan buena idea usar enums, ya que no se comportan como objetos una vez convertido a JavaScript, al menos no siempre 😅
Aquí un video de lo que digo, mucho mejor explicado a detalle:
https://www.youtube.com/watch?v=jjMbPt_H3RQ

Los enum sirven para definir un conjunto de opciones, que viene siendo como un diccionario de datos, en donde defines una llave y un valor.

El código necesario para el archivo 01-camera.ts

import { Camera, CameraResultType } from '@capacitor/camera';

const takePicture = async () => {
  const image = await Camera.getPhoto({
    quality: 90,
    allowEditing: true,
    resultType: CameraResultType.Uri
  })
}

Enums

El enum nos permite configurar un set de opciones, es parecido a los literals types, se declaran así.

enum ROLES {
  ADMIN = 'ADMIN',
  SELLER = 'SELLER',
  COSTUMER = 'COSTUMER',
};

Es aconsejable que nos enums vayan es mayúscula.

Esto es importante para hacer múltiples opciones cuando tenemos diferentes opciones.

Por ejemplo vamos a crear un usuario y con el enum de roles antes declarado vamos a asignarle una propiedad de rol dentro del usuario usando un unión type así

type User = {
  username: string;
  role: ROLES;
};

Pero entonces ¿cómo usamos esto? lo que haremos es usar las propiedades el enum y el unión type antes declarado para dar el tipado a una variable o constante.

const juanUser:User

Después vamos a crear un objeto y empezamos a asignar las propiedades

const juanUser:User = {
  username: 'Juan david el MACHO',
}

Pero ¿Cómo asignamos el enumerado? lo hacemos de la siguiente manera

const juanUser:User = {
  username: 'Juan david el MACHO',
  role: ROLES.ADMIN
}

De esta forma podemos usar los enumerados junto a los unión types.

Ahora si definitivamente me paso a typescript.

La importancia de estos enums es increible, me sirvió mucho en mi trabajo !!!❤️

Estuvo muy buena esta clase Nico, no habia visto de esta manera los Enums y el potencial que tienen

muy interesante la función “enums”