0Pricing
TypeScript Academy · Lección

La palabra clave as para aserciones de tipos

Sobrescriba deliberadamente los tipos inferidos con as.

La palabra clave as para aserciones de tipos 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.

¿Qué es una aserción de tipo?

Una aserción de tipo indica al compilador «confíe en mí, sé que este valor es de tipo T». Se utiliza la palabra clave as: value as Type. Esto cambia la forma en que el comprobador de tipos ve el valor, no el valor en sí.

const raw: unknown = 'hello world';
const text = raw as string;
console.log(text.toUpperCase());

La sintaxis as

Escriba la expresión, luego as y después el tipo de destino. También existe una sintaxis antigua con corchetes angulares, pero se prefiere as porque funciona en todas partes, incluidos los archivos JSX/TSX.

const value: unknown = 42;
const n = value as number;
console.log(n + 8);

Las aserciones no cambian el tiempo de ejecución

Esto es fundamental: las aserciones son una instrucción que solo existe en tiempo de compilación. Se eliminan cuando se ejecuta el código. No hay conversión ni validación; si realiza una aserción incorrecta, el valor en tiempo de ejecución no cambia y puede comportarse de forma inesperada.

const v: unknown = 'not a number';
const n = v as number; // compiles, but v is still a string
console.log(typeof n); // 'string' at runtime!

Cuándo son válidas las aserciones

TypeScript solo permite aserciones directas entre tipos que se solapan, es decir, cuando uno se puede asignar al otro. Puede hacer una aserción de unknown a string, o ampliar o estrechar un tipo dentro de una relación.

const u: unknown = 'ok';
const s = u as string; // valid: unknown overlaps everything
const broad = s as string | number; // valid widening
console.log(s, broad);

Aserciones directas no válidas

Si dos tipos no tienen ninguna relación, TypeScript rechaza una aserción directa por considerarla probablemente un error. Por ejemplo, se bloquea hacer una aserción directa de string a number.

const s = 'hello';
// const n = s as number; // Error: neither type sufficiently overlaps
console.log('Direct unrelated assertions are blocked');

Estrechar una unión con as

Un uso válido habitual consiste en afirmar que un valor de unión es uno de sus miembros cuando usted dispone de información que el compilador no tiene. Úselo con moderación: una comprobación en tiempo de ejecución suele ser más segura.

type Shape = { kind: 'circle'; r: number } | { kind: 'square'; s: number };
const data: Shape = { kind: 'circle', r: 5 };
const circle = data as { kind: 'circle'; r: number };
console.log(circle.r);

Afirmar tipos de elementos del DOM

Un uso clásico en situaciones reales: las consultas del DOM devuelven un tipo amplio como HTMLElement | null. Cuando conoce el elemento específico, puede afirmarlo para acceder a propiedades propias de ese elemento.

// document.getElementById returns HTMLElement | null
// const input = document.getElementById('email') as HTMLInputElement;
// console.log(input.value);
console.log('Assert HTMLElement to HTMLInputElement for .value');

Por qué se necesitan las aserciones del DOM

Las API del DOM no pueden saber qué elemento concreto obtendrá, por lo que devuelven tipos generales. Afirmar el subtipo específico, por ejemplo HTMLInputElement, permite acceder a propiedades como value o checked.

// const canvas = document.querySelector('#c') as HTMLCanvasElement;
// const ctx = canvas.getContext('2d');
console.log('querySelector returns Element | null; assert to specialize');

Las aserciones const son un caso especial

Ya ha visto as const. Es una aserción especial que hace que un valor sea profundamente de solo lectura y tenga tipos literales. Es la única aserción que siempre es segura, ya que solo estrecha el tipo.

const tuple = [1, 2, 3] as const;
// type: readonly [1, 2, 3]
console.log(tuple.length);

Las aserciones eluden la seguridad

Como las aserciones indican al compilador que deje de comprobar, trasladan la responsabilidad a usted. Una aserción incorrecta puede ocultar un error de tipos real hasta que provoque un fallo en tiempo de ejecución. Utilícelas solo cuando realmente sepa más que el compilador.

const data: unknown = { id: 1 };
const user = data as { id: number; name: string };
// name does not exist at runtime
console.log(user.name); // undefined, no compile error

Prefiera estrechar a afirmar

Cuando sea posible, prefiera el estrechamiento en tiempo de ejecución, mediante guardas de tipo, a las aserciones. El estrechamiento demuestra el tipo; la aserción solo lo afirma. Reserve as para los casos que el estrechamiento no puede expresar, como la especialización de elementos del DOM.

function safe(v: unknown): number {
  if (typeof v === 'number') return v; // proven
  return 0;
}
console.log(safe(10), safe('x'));

Comprobación rápida

Compruebe cuánto entiende de las aserciones de tipo.

Resumen: aserciones as

Ha aprendido que:

  • value as Type indica al compilador que trate un valor como si fuera de un tipo determinado.
  • Las aserciones solo existen en tiempo de compilación: no realizan conversiones ni comprobaciones en tiempo de ejecución.
  • Solo se permiten entre tipos que se solapan.
  • Usos válidos habituales: estrechar unknown y especializar tipos de elementos del DOM. Prefiera el estrechamiento cuando sea posible.

A continuación, veremos el operador de aserción de no nulidad.

const raw: unknown = 'data';
const s = raw as string;
console.log(s.length);

Preguntas frecuentes

¿La lección «La palabra clave as para aserciones de tipos» es gratis?

Sí — el texto completo de «La palabra clave as para aserciones de tipos» 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 «La palabra clave as para aserciones de tipos»?

Sobrescriba deliberadamente los tipos inferidos con as. 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 «La palabra clave as para aserciones de tipos»?

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