TypeScript ofrece un sistema de tipos sólido, pero ciertos tipos pueden resultar confusos, como cualquiera, desconocido y nunca. Analicémoslos para comprenderlos mejor.

El cualquier tipo

El tipo any es el más simple de los tres. Básicamente, deshabilita la verificación de tipos, lo que permite que una variable contenga cualquier tipo de valor. Por ejemplo:

let value: any;
value = 42;             // number
value = "Hello";        // string
value = [1, 2, 3];      // array
value = () => {};       // function
value = { key: "val" }; // object
value = new Date();     // date

En todos estos casos, TypeScript no genera ningún error, lo que nos permite realizar cualquier operación en la variable sin restricciones de tipo. Esto puede resultar útil al migrar un proyecto de JavaScript a TypeScript. Sin embargo, confiar en cualquiera anula los beneficios de la seguridad de tipos, lo que la convierte en una mala elección en la mayoría de los casos. En su lugar, considere usar desconocido.

El tipo desconocido

El tipo desconocido es más seguro que cualquier otro porque requiere comprobaciones de tipo antes de realizar operaciones. Representa el conjunto de todos los valores posibles, pero con seguridad de tipos aplicada.

let value: unknown;
value = 42;
value = "Hello";

// To perform operations, we need to narrow down the type
if (typeof value === "number") {
  console.log(value   1); // TypeScript knows value is a number here
}

El uso de desconocido es beneficioso para funciones que aceptan cualquier tipo de entrada, como funciones de registro, ya que exige verificaciones de tipos antes de continuar con las operaciones.

El tipo nunca

El tipo nunca representa el conjunto vacío de valores, lo que indica que algo nunca debería ocurrir. No se puede asignar ningún valor a un tipo nunca, lo que lo hace útil para comprobaciones exhaustivas y representa código inalcanzable.

type User = { type: "admin" } | { type: "standard" };

function handleUser(user: User) {
  switch (user.type) {
    case "admin":
      // handle admin
      break;
    case "standard":
      // handle standard
      break;
    default:
      const _exhaustiveCheck: never = user;
      // This ensures all cases are handled
  }
}

Si se agrega un nuevo tipo de usuario, TypeScript generará un error, lo que garantiza que se aborden todos los casos, lo que lo hace invaluable para mantener controles exhaustivos en su código.

Conclusión

Comprender cualquiera, desconocido y nunca mejora la seguridad de tipos de TypeScript. Utilice cualquiera con moderación, prefiriendo desconocido para comprobaciones de tipos más seguros y aproveche nunca para comprobaciones exhaustivas y códigos inalcanzables. Estos tipos, cuando se usan correctamente, hacen de TypeScript una herramienta poderosa para crear aplicaciones confiables.
¡Feliz codificación!