0Pricing
TypeScript Academy · Lección

Aserciones dobles y sus riesgos

Descubra cuándo se necesita as unknown as T y por qué es peligroso.

Aserciones dobles y sus riesgos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 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.

¿Qué es una aserción doble?

Una aserción doble encadena dos conversiones con as, normalmente pasando por unknown: value as unknown as T. Esto fuerza una conversión que el compilador rechazaría de otro modo.

const s = 'hello';
const n = s as unknown as number; // forced
console.log(typeof n); // still 'string' at runtime!

Por qué TS bloquea las conversiones directas

TypeScript bloquea s as number cuando string y number no se solapan, porque casi con toda seguridad se trata de un error. Este error le protege de aserciones sin sentido.

const s = 'text';
// const n = s as number; // Error: types do not sufficiently overlap
console.log('Direct unrelated assertion is rejected');

Cómo unknown permite la conversión

Todos los tipos se pueden asignar a unknown, y se puede hacer una aserción de unknown a cualquier tipo. Pasar por este tipo satisface la regla de solapamiento en dos pasos y omite por completo la comprobación de seguridad.

const s = 'text';
const step1 = s as unknown; // always allowed
const step2 = step1 as number; // allowed from unknown
console.log(typeof step2);

La aserción doble engaña al compilador

El resultado se compila, pero el valor en tiempo de ejecución no cambia. Ha indicado al sistema de tipos algo falso. Cualquier código posterior que confíe en el tipo afirmado puede fallar de forma impredecible.

const fake = 'oops' as unknown as number;
console.log(fake + 1); // 'oops1' — string concatenation at runtime

Un uso indebido realista

A veces, los desarrolladores hacen aserciones dobles para silenciar errores cuando las estructuras no coinciden. Esto oculta errores reales: el valor nunca tuvo las propiedades afirmadas.

type User = { id: number; name: string };
const partial = { id: 1 };
const user = partial as unknown as User;
console.log(user.name); // undefined at runtime

Cuándo es necesaria una aserción doble

En ocasiones es legítima; por ejemplo, para conectar tipos incompatibles de bibliotecas que sabe que son compatibles estructuralmente en tiempo de ejecución, o en código de bajo nivel cuando conoce realmente la disposición de la memoria. Estos casos son poco frecuentes.

// Bridging a known-compatible external type:
type LibA = { value: number };
type LibB = { value: number };
const a: LibA = { value: 5 };
const b = a as unknown as LibB; // structurally identical
console.log(b.value);

Por qué es un code smell

Una aserción doble indica que está imponiendo sus decisiones al sistema de tipos en lugar de trabajar con él. Cada una es un punto en el que el compilador ya no puede protegerle, por lo que los revisores deben examinar con atención cada aparición.

// Treat 'as unknown as' as a red flag in code review.
const data: unknown = JSON.parse('{}');
// Better: validate with a type guard instead of forcing.
console.log('Prefer validation over double assertion');

Prefiera la validación

En lugar de forzar un tipo, valide los datos y refínelos. Una guarda de tipos demuestra la estructura en tiempo de ejecución y le proporciona el mismo resultado tipado sin engañar al compilador.

type User = { id: number; name: string };
function isUser(v: unknown): v is User {
  return typeof v === 'object' && v !== null &&
    'id' in v && 'name' in v;
}
const raw: unknown = { id: 1, name: 'Sam' };
if (isUser(raw)) console.log(raw.name);

Prefiera una conversión adecuada

Si realmente necesita un tipo diferente en tiempo de ejecución, convierta el valor en lugar de hacer una aserción. La conversión cambia los datos; la aserción solo cambia la etiqueta.

const s = '42';
const n = Number(s); // real conversion
console.log(n + 1, typeof n);

Documente el caso válido poco frecuente

Cuando una aserción doble esté realmente justificada, añada un comentario que explique por qué es segura. Los futuros encargados del mantenimiento necesitan conocer la garantía en tiempo de ejecución que hace válida la conversión.

type Raw = { ts: number };
type Event = { ts: number };
const raw: Raw = { ts: 100 };
// Safe: Raw and Event are structurally identical.
const ev = raw as unknown as Event;
console.log(ev.ts);

Resumen de las pautas

Como regla general: si está escribiendo as unknown as, deténgase y pregúntese si la validación o la conversión serían más seguras. Nueve de cada diez veces, lo serían.

// Decision: validate? convert? or genuinely bridge identical types?
const input = '7';
const parsed = Number.parseInt(input, 10); // convert, don't force
console.log(parsed);

Comprobación rápida

Compruebe su comprensión de las aserciones dobles.

Repaso: aserciones dobles

Ha aprendido que:

  • value as unknown as T fuerza una conversión que TypeScript rechazaría de otro modo.
  • Funciona porque unknown se solapa con todos los tipos, pero no cambia nada en tiempo de ejecución.
  • Es un code smell: está imponiendo sus decisiones al sistema de tipos y perdiendo su protección.
  • Prefiera la validación (guardas de tipos) o una conversión real.

A continuación, aserciones y guardas de tipos frente a frente.

// Validate, don't force:
const raw: unknown = '99';
const n = typeof raw === 'string' ? Number(raw) : 0;
console.log(n);

Preguntas frecuentes

¿La lección «Aserciones dobles y sus riesgos» es gratis?

Sí — el texto completo de «Aserciones dobles y sus riesgos» 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 «Aserciones dobles y sus riesgos»?

Descubra cuándo se necesita as unknown as T y por qué es peligroso. 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 3 de 4.

¿Cuánto tiempo toma la lección «Aserciones dobles y sus riesgos»?

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

  1. La palabra clave as para aserciones de tipos
  2. Operador de aserción de no nulo
  3. Aserciones dobles y sus riesgos
  4. Aserciones frente a type guards
← Volver a TypeScript Academy