Probar los tipos en TypeScript

Aserciones que corren en el compilador, no en tiempo de ejecución.

type Equal<A, B> =
  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
    ? true
    : false;

type Expect<T extends true> = T;

type Pluck<T, K extends keyof T> = T[K];

interface Run {
  lang: string;
  tpm: number;
}

type _keys = Expect<Equal<keyof Run, "lang" | "tpm">>;
type _value = Expect<Equal<Pluck<Run, "tpm">, number>>;
type _notAny = Expect<Equal<Pluck<Run, "lang">, string>>;

function stars(tpm: number): 1 | 3 {
  return tpm >= 100 ? 3 : 1;
}

type _return = Expect<Equal<ReturnType<typeof stars>, 1 | 3>>;

// @ts-expect-error una cadena no es un número
const wrong: number = "98";

console.log(stars(104), typeof wrong);

Cómo funciona

1. Equal compara dos tipos con exactitud, no solo asignabilidad.
2. Expect no compila cuando el chequeo es falso.
3. Un comentario @ts-expect-error asevera que algo no debe compilar.

Palabras clave y builtins usados aquí

• const
• extends
• false
• function
• interface
• number
• return
• string
• type

El intento, en números

Líneas

28

Caracteres a escribir

641

Tokens

190

Ritmo de tres estrellas

110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 104 segundos.

Escribe este fragmento

Paso 3 de 3 en Exhaustividad y pruebas; paso 11 de 12 en Programación a nivel de tipos.

← Anterior Siguiente →