¿Cómo verifico que un bloque de interruptores sea exhaustivo en TypeScript?

Tengo un código:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        // Forgot about Blue
    }

    throw new Error('Did not expect to be here');
}

Olvidé manejar el Color.Bluecaso y preferiría haber recibido un error de compilación. ¿Cómo puedo estructurar mi código de modo que TypeScript marque esto como un error?

Para hacer esto, usaremos el nevertipo (introducido en TypeScript 2.0) que representa valores que "no deberían" ocurrir.

El primer paso es escribir una función:

function assertUnreachable(x: never): never {
    throw new Error("Didn't expect to get here");
}

Luego úselo en el defaultcaso (o de manera equivalente, fuera del interruptor):

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
    }
    return assertUnreachable(c);
}

En este punto, verá un error:

return assertUnreachable(c);
       ~~~~~~~~~~~~~~~~~~~~~
       Type "Color.Blue" is not assignable to type "never"

¡El mensaje de error indica los casos que olvidó incluir en su exhaustivo cambio! Si deja varios valores, verá un error sobre, por ejemplo Color.Blue | Color.Yellow.

Tenga en cuenta que si lo está utilizando strictNullChecks, lo necesitará antes returnde la assertUnreachablellamada (de lo contrario, es opcional).

Puedes ponerte un poco más elegante si quieres. Si está utilizando una unión discriminada, por ejemplo, puede ser útil recuperar la propiedad discriminante en la función de aserción para fines de depuración. Se parece a esto:

// Discriminated union using string literals
interface Dog {
    species: "canine";
    woof: string;
}
interface Cat {
    species: "feline";
    meow: string;
}
interface Fish {
    species: "pisces";
    meow: string;
}
type Pet = Dog | Cat | Fish;

// Externally-visible signature
function throwBadPet(p: never): never;
// Implementation signature
function throwBadPet(p: Pet) {
    throw new Error('Unknown pet kind: ' + p.species);
}

function meetPet(p: Pet) {
    switch(p.species) {
        case "canine":
            console.log("Who's a good boy? " + p.woof);
            break;
        case "feline":
            console.log("Pretty kitty: " + p.meow);
            break;
        default:
            // Argument of type 'Fish' not assignable to 'never'
            throwBadPet(p);
    }
}

Este es un patrón agradable porque obtienes seguridad en tiempo de compilación para asegurarte de manejar todos los casos que esperabas. Y si obtiene una propiedad verdaderamente fuera de alcance (por ejemplo, algún llamador JS creó una nueva species), puede lanzar un mensaje de error útil.

No necesita usar neverni agregar nada al final de su switch.

Si

• Su switchestado de cuenta regresa en cada caso
• Tienes strictNullChecksactivado el indicador de compilación de mecanografiado
• Tu función tiene un tipo de retorno especificado
• El tipo de retorno no es undefinedovoid

Obtendrá un error si su switchdeclaración no es exhaustiva, ya que habrá un caso en el que no se devolverá nada.

De tu ejemplo, si lo haces

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        // Forgot about Blue
    }
}

Obtendrá el siguiente error de compilación:

La función carece de declaración de retorno final y el tipo de retorno no se incluye undefined.

Solución

Lo que hago es definir una clase de error:

export class UnreachableCaseError extends Error {
  constructor(val: never) {
    super(`Unreachable case: ${JSON.stringify(val)}`);
  }
}

y luego lanza este error en el caso predeterminado:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
  switch(c) {
      case Color.Red:
          return 'red, red wine';
      case Color.Green:
          return 'greenday';
      case Color.Blue:
          return "Im blue, daba dee daba";
      default:
          // Argument of type 'c' not assignable to 'never'
          throw new UnreachableCaseError(c);
  }
}

Creo que es más fácil de leer que el enfoque de función recomendado por Ryan, porque la throwcláusula tiene el resaltado de sintaxis predeterminado.

Insinuación

La biblioteca ts-essentials tiene una clase UnreachableCaseError exactamente para este caso de uso

Consideraciones de tiempo de ejecución

Tenga en cuenta que el código mecanografiado se transpila a javascript: por lo tanto, todas las comprobaciones mecanografiadas sólo funcionan en tiempo de compilación y no existen en tiempo de ejecución: es decir, no hay garantía de que la variable csea ​​realmente de tipo Color.
Esto es diferente de otros lenguajes: por ejemplo, Java también verificará los tipos en tiempo de ejecución y arrojará un error significativo si intenta llamar a la función con un argumento de tipo incorrecto, pero javascript no lo hace.

Esta es la razón por la que es importante lanzar una excepción significativa en el defaultcaso: Stackblitz: arrojar un error significativo

Si no hiciste esto, la función getColorName()regresaría implícitamente undefined(cuando se llama con un argumento inesperado): Stackblitz: return any

En los ejemplos anteriores, usamos directamente una variable de tipo anypara ilustrar el problema. Es de esperar que esto no suceda en proyectos del mundo real, pero hay muchas otras formas de obtener una variable de un tipo incorrecto en tiempo de ejecución.
Aquí hay algunos que ya he visto (y yo mismo cometí algunos de estos errores):

• usando formas angulares - estas no son seguras de tipos: todos los valores de campo de formulario son de tipo any
  ng-forms Stackblitz ejemplo
• implícito cualquiera está permitido
• se utiliza un valor externo y no se valida (por ejemplo, la respuesta http del servidor simplemente se envía a una interfaz)
• leemos un valor del almacenamiento local que ha escrito una versión anterior de la aplicación (estos valores han cambiado, por lo que la nueva lógica no comprende el valor anterior)
• usamos algunas bibliotecas de terceros que no son seguras de tipos (o simplemente tienen un error)

Así que no sea perezoso y escriba este caso adicional predeterminado: puede evitarle muchos dolores de cabeza ...

Sobre la base de la respuesta de Ryan, descubrí aquí que no hay necesidad de ninguna función adicional. Podemos hacer directamente:

function getColorName(c: Color): string {
  switch (c) {
    case Color.Red:
      return "red";
    case Color.Green:
      return "green";
    // Forgot about Blue
    default:
      const _exhaustiveCheck: never = c;
      throw new Error("How did we get here?");
  }
}

Puedes verlo en acción aquí en TS Playground

typescript-eslinttiene una regla de "verificación exhaustiva en el interruptor con tipo de unión" :
@ typescript-eslint / switch-exhaustiveness-check

Como un buen giro en la respuesta de Ryan, puede reemplazarlo nevercon una cadena arbitraria para que el mensaje de error sea más fácil de usar.

function assertUnreachable(x: 'error: Did you forget to handle this type?'): never {
    throw new Error("Didn't expect to get here");
}

Ahora obtienes:

return assertUnreachable(c);
       ~~~~~~~~~~~~~~~~~~~~~
       Type "Color.Blue" is not assignable to type "error: Did you forget to handle this type?"

Esto funciona porque neverse puede asignar a cualquier cosa, incluida una cadena arbitraria.

Sobre la base de las respuestas de Ryan y Carlos , puede usar un método anónimo para evitar tener que crear una función con nombre separada:

function getColorName(c: Color): string {
  switch (c) {
    case Color.Red:
      return "red";
    case Color.Green:
      return "green";
    // Forgot about Blue
    default:
      ((x: never) => {
        throw new Error(`${x} was unhandled!`);
      })(c);
  }
}

Si su cambio no es exhaustivo, obtendrá un error de tiempo de compilación .

Para evitar las advertencias de Typecript o linter:

    default:
        ((_: never): void => {})(c);

en contexto:

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        default:
            ((_: never): void => {})(c);
    }
}

La diferencia entre esta solución y las demás es

• no hay variables nombradas sin referencia
• no lanza una excepción ya que Typecript hará cumplir que el código se neverejecutará de todos modos

En casos realmente simples, cuando solo necesita devolver una cadena por valor de enumeración, es más fácil (en mi humilde opinión) usar alguna constante para almacenar el diccionario de resultados en lugar de usar el interruptor. Por ejemplo:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
  const colorNames: Record<Color, string> = {
    [Color.Red]: `I'm red`,
    [Color.Green]: `I'm green`,
    [Color.Blue]: `I'm blue, dabudi dabudai`,   
  }

  return colorNames[c] || ''
}

Entonces, aquí tendrá que mencionar cada valor de enumeración en constante, de lo contrario obtendrá un error como, por ejemplo, si falta Blue:

TS2741: Falta la propiedad 'Blue' en el tipo '{[Color.Red]: string; [Color.Verde]: cadena; ' pero se requiere en el tipo 'Registro'.

Sin embargo, a menudo no es el caso y entonces es realmente mejor lanzar un error como propuso Ryan Cavanaugh.

También me molestó un poco cuando descubrí que esto no funcionaría también:

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
    }
    return '' as never // I had some hope that it rises a type error, but it doesn't :)
}

Cree una función personalizada en lugar de utilizar una switchdeclaración.

export function exhaustSwitch<T extends string, TRet>(
  value: T,
  map: { [x in T]: () => TRet }
): TRet {
  return map[value]();
}

Uso de ejemplo

type MyEnum = 'a' | 'b' | 'c';

const v = 'a' as MyEnum;

exhaustSwitch(v, {
  a: () => 1,
  b: () => 1,
  c: () => 1,
});

Si luego agrega da MyEnum, recibirá un errorProperty 'd' is missing in type ...