TypeScript Academy · Lección

Comprender unknown frente a any

Descubra por qué unknown es la alternativa segura para tipos frente a any.

Comprender unknown frente a any es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Dos tipos superiores

TypeScript tiene dos tipos que pueden contener cualquier valor: any y unknown. Parecen similares, pero se comportan de formas muy distintas. Elegir el adecuado es una habilidad fundamental para escribir código con seguridad de tipos.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any desactiva la comprobación de tipos

any es una vía de escape que desactiva el comprobador de tipos para ese valor. Puede acceder a cualquier propiedad o llamarlo como una función; el compilador permanece en silencio, incluso cuando el código fallaría en tiempo de ejecución.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown le obliga a comprobar

unknown también acepta cualquier valor, pero no puede usarlo hasta demostrar qué es. El compilador bloquea el acceso a propiedades y las llamadas hasta que reduzca el tipo.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

Reducir unknown con typeof

Una protección con typeof reduce unknown a un tipo concreto dentro del bloque. Una vez reducido, todos los métodos de ese tipo están disponibles de forma segura.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Por qué unknown es más seguro

unknown representa una incertidumbre honesta: «Todavía no sé qué es esto». Le obliga a validar antes de usar el valor y detecta errores en tiempo de compilación. any simplemente oculta la incertidumbre y los errores.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

Asignar a unknown y desde unknown

Cualquier valor se puede asignar a unknown. Sin embargo, unknown solo se puede asignar a unknown o any, no a tipos específicos sin reducirlo. Esta asimetría es lo que lo mantiene seguro.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any se propaga por el código

Una característica peligrosa de any es que se propaga. Una vez que un valor es any, todo lo que se derive de él también se convierte en any, erosionando silenciosamente la seguridad de tipos en todo el programa.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown contiene el riesgo

Con unknown, la incertidumbre permanece en su lugar. Debe reducir el tipo explícitamente en cada frontera, de modo que las operaciones inseguras no puedan propagarse a otras partes. El riesgo queda contenido donde corresponde.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

Tipar las fronteras de API y JSON

Los datos externos —JSON, respuestas de red y entradas del usuario— no ofrecen garantías. Tiparlos como unknown en lugar de any obliga a validarlos antes de confiar en ellos, lo que constituye la opción segura predeterminada.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Cuándo es aceptable any

any puede ser práctico en ocasiones: prototipos rápidos, migraciones graduales desde JavaScript o interoperabilidad con bibliotecas sin tipos. Sin embargo, trátelo como una marca temporal, no como un hábito. Prefiera unknown siempre que sea posible.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Una comparación práctica

Comparación lado a lado: la versión con any compila, pero puede fallar; la versión con unknown se niega a compilar el acceso inseguro. El compilador está cumpliendo su función: protegerle.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Comprobación rápida

Compruebe cuánto ha comprendido sobre unknown y any.

Resumen: unknown frente a any

Puntos clave:

any desactiva la comprobación de tipos y se propaga a través de los valores derivados.
unknown acepta cualquier valor, pero bloquea su uso hasta que lo reduzca.
Use unknown para datos externos (JSON, API y entradas del usuario) con el fin de forzar su validación.
Reserve any para migraciones o interoperabilidad sin tipos, como marca temporal.

A continuación, exploraremos el tipo vacío: never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Preguntas frecuentes

¿La lección «Comprender unknown frente a any» es gratis?

Sí — el texto completo de «Comprender unknown frente a any» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Comprender unknown frente a any»?

Descubra por qué unknown es la alternativa segura para tipos frente a any. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Comprender unknown frente a any»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a TypeScript Academy