Estoy usando TypeScript para desarrollar mi aplicación. Estoy tratando de crear una interfaz (o tipo) que sea una de varias constantes, o una cadena aleatoria.

Pseudo código para describir lo que estoy tratando de construir:

contants.ts:

export const ERROR_A = "Error A";
export const ERROR_B = "Error B";
export const ERROR_C = "Error C";

types.ts:

type SWITCH_ERROR = ERROR_A | ERROR_B | ERROR_C | string

Sé que de esta manera cada cadena puede ser un error. La razón por la que quiero hacerlo así es para que el código base se pueda mantener fácilmente y cada error conocido tenga su tipo. El error luego se manejará en una declaración de cambio como esta:

switchExample.ts:

export const someFunc(error: SwitchError): void => {
  switch(error) {
    case ERROR_A:
      // Do something
    // ... continue for each error.
    default:
      // Here the plain string should be handled.
  }
}

El problema es que intenté hacerlo así:

import { ERROR_A } from "./some/Path";

export type SwitchError = ERROR_A;

Pero esto arroja el error:

[ts] Cannot find name 'ERROR_A'.

¿Qué estoy haciendo mal? ¿Cómo se diseñaría algo como esto en TypeScript? ¿O es este mal diseño? Si es así, ¿de qué otra manera podría hacer esto?

5
J. Hesters 16 oct. 2018 a las 10:32

2 respuestas

La mejor respuesta

El error se debe a que solo ha definido ERROR_A como valor pero está intentando utilizarlo como tipo. (El mensaje de error no es útil; recientemente presenté un problema para mejorarlo). Para definir cada nombre como un valor y un tipo, puede usar lo siguiente en constants.ts:

export const ERROR_A = "Error A";
export type ERROR_A = typeof ERROR_A;
export const ERROR_B = "Error B";
export type ERROR_B = typeof ERROR_B;
export const ERROR_C = "Error C";
export type ERROR_C = typeof ERROR_C;

La sugerencia de Hayden Hall de usar una enumeración también es buena, ya que los miembros de la enumeración se definen automáticamente como nombres y tipos. Pero puede evitar todo esto y simplemente escribir type SWITCH_ERROR = string; es equivalente a type SWITCH_ERROR = ERROR_A | ERROR_B | ERROR_C | string cuando ERROR_A, ERROR_B y ERROR_C son cadenas específicas.

5
Matt McCutchen 16 oct. 2018 a las 11:56

Algo como lo siguiente debería resolver el problema (asumiendo que su error es una cadena):

enum Errors {
    ERROR_A = 'Error A',
    ERROR_B = 'Error B',
    ERROR_C = 'Error C',
}

function handleError(error: string) : void {
  switch(error) {
    case Errors.ERROR_A:
      // Handle ERROR_A
    case Errors.ERROR_B:
      // Handle ERROR_B
    case Errors.ERROR_C:
      // Handle ERROR_C
    default:
      // Handle all other errors...
  }
}
2
Hayden Hall 16 oct. 2018 a las 09:07