enumeracion - numeric enums typescript

Cómo comparar enumeraciones en TypeScript

Question

En TypeScript, quiero comparar dos variables que contienen valores enum. Aquí está mi ejemplo de código mínimo:

enum E {
  A,
  B
}

let e1: E = E.A
let e2: E = E.B

if (e1 === e2) {
  console.log("equal")
}

Al compilar con tsc (v 2.0.3) obtengo el siguiente error:

TS2365: El operador ''==='' no se puede aplicar a los tipos ''EA'' y ''E.B''.

Lo mismo con == !== y != . Intenté agregar la palabra clave const pero eso parece no tener efecto. La especificación de TypeScript dice lo siguiente:

4.19.3 Los operadores <,>, <=,> =, ==,! =, === y! ==

Estos operadores requieren que uno o ambos tipos de operandos sean asignables al otro. El resultado es siempre del tipo primitivo booleano.

Lo cual (creo) explica el error. Pero, ¿cómo puedo solucionarlo?

Nota al margen
Estoy usando el editor Atom con atom-typescript , y no recibo ningún error / advertencia en mi editor. Pero cuando ejecuto tsc en el mismo directorio, aparece el error anterior. Pensé que debían usar el mismo archivo tsconfig.json , pero aparentemente ese no es el caso.

Answer 1

El error se produce porque el compilador se da cuenta de que la declaración siempre es falsa y, por lo tanto, redundante. Declaras dos variables que claramente no son iguales y luego intentas y ves si son iguales.

Si lo cambias a por ejemplo:

enum E { A, B } foo() { let e1: E = EA let e2: E e2 = foo(); if (e1 === e2) { console.log("equal") } } bar(): E { return EB }

Debería compilarse sin error.

En una nota al margen, algo. me gusta

let e1 = EA; if (e1 && e1 === EB) { ... }

tampoco se compilaría, ya que e1 en este caso es 0 (ya que A es la primera ''opción'' de enumeración) y, por lo tanto, es false que significa que nunca se alcanzaría el segundo estado (sin tener en cuenta si la segunda declaración sería válida en este caso)

Answer 2

En mi caso, ninguna de las soluciones anteriores funcionó, el motivo fue que estaba asignando el valor de enumeración al objeto de enumeración.

Después de eso, estaba intentando saber si la enumeración era equivalente a otro objeto de enumeración ... así que he creado las siguientes funciones genéricas :

  public static enumEquals<T>(e: any, e1: T, e2: T): boolean {
    const v1 = this.enumValue(e, e1);
    return v1 === this.enumValue(e, e2, typeof v1);
  }

  private static enumValue<T>(enumType: any, value: T, validType?: string) {
    let v = enumType[value];
    if (!validType) {
      return v;
    }
    while (typeof v !== validType) {
      v = enumType[v];
    }
    return v;
  }

Este es un ejemplo de mi caso de prueba:

enum SomeEnum {
  VALUE1, VALUE2, VALUE3, VALUE_DEF
}

const enumRefKey = localStorage.getItem(''someKey'');
const parsedEnum = SomeEnum[enumRefKey] || SomeEnum.VALUE_DEF;
console.log(parsedEnum);
if (parsedEnum === SomeEnum.VALUE_DEF) {
  // do stuff
}

Obviamente, ese código no funcionó, después de haber probado las soluciones que se dan aquí en estas preguntas, he encontrado que cuando enumRefKey es una consola válida . Log (parsedEnum) estaba imprimiendo números y el texto VALUE_DEF cuando no lo está. El mismo resultado sucedió usando todas las otras soluciones:

• ParsedEnum como SomeEnum
• parsedEnum.valueOf ()
• SomeEnum [parsedEnum]

La solución que utiliza los métodos genéricos se ve así:

enum SomeEnum {
  VALUE1, VALUE2, VALUE3, VALUE_DEF
}

const enumRefKey = localStorage.getItem(''someKey'');
const parsedEnum = SomeEnum[enumRefKey] || SomeEnum.VALUE_DEF;
console.log(parsedEnum);
if (this.enumEquals(SomeEnum, parsedEnum, SomeEnum.VALUE_DEF) {
  // do stuff
}

Espero que esto ayude a alguien.

Answer 3

Hay otra forma: si no desea que el código javascript generado se vea afectado de alguna manera, puede usar type cast:

let e1: E = E.A
let e2: E = E.B


if (e1 as E === e2 as E) {
  console.log("equal")
}

En general, esto se debe a la inferencia de tipos basada en control-flujo. Con la implementación actual de escritura de tipos, se desactiva siempre que se trate de una llamada de función, por lo que también puede hacer esto:

let id = a => a

let e1: E = id(E.A)
let e2: E = id(E.B)

if (e1 === e2) {
  console.log(''equal'');
}

Lo extraño es que todavía no hay error si se declara que la función id devuelve exactamente el mismo tipo que su documento:

function id<T>(t: T): T { return t; }

Answer 4

Lo único que me funcionó (en mecanografía 2.2.1) fue esto:

if (E[e1] === E[e2]) {
  console.log("equal")
}

Esto compara las cadenas que representan los nombres (por ejemplo, "A" y "B").

Answer 5

Pues creo que encontré algo que funciona:

if (e1.valueOf() === e2.valueOf()) {
  console.log("equal")
}

Pero me sorprende un poco que esto no se mencione en ninguna parte de la documentación.

Answer 6

Si fue capaz de comparar dos enumeraciones con esto

 if (product.ProductType && 
       (product.ProductType.toString() == ProductTypes[ProductTypes.Merchandises])) {
      // yes this item is of merchandises
  } 

con ProductTypes siendo esta export enum ProductTypes{Merchandises,Goods,...}