Mecánica de ampliación y reducción de tipos
Aprenda cómo TypeScript amplía los tipos y cuándo evitarlo.
Mecánica de ampliación y reducción 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 la ampliación de tipos?
La ampliación de tipos ocurre cuando TypeScript infiere un tipo más amplio que el que escribió. Asignar let x = "hello" lo amplía a string, no al literal "hello".
let x = "hello"; // inferred: string, not "hello"
let y = 42; // inferred: number, not 42Ampliación con let frente a const
Las variables declaradas con const conservan su tipo literal porque no se pueden reasignar. let se amplía al tipo base.
const a = "world"; // type: "world"
let b = "world"; // type: stringCómo evitar la ampliación con anotaciones de tipo
Anotar explícitamente una variable let evita la ampliación y fija el tipo literal.
let direction: "left" | "right" = "left";
// direction = "up"; // Error: not assignableReducción con typeof
TypeScript reduce un tipo unión dentro de las comprobaciones con typeof, lo que proporciona un tipo preciso en esa rama.
function format(val: string | number) {
if (typeof val === "string") {
return val.toUpperCase(); // val: string here
}
return val.toFixed(2); // val: number here
}Reducción con comprobaciones de igualdad
Las comprobaciones de igualdad con valores literales también reducen el tipo dentro de la rama.
type Direction = "left" | "right" | "up";
function handle(dir: Direction) {
if (dir === "left") {
console.log("Going left"); // dir: "left"
}
}Análisis del flujo de control
TypeScript realiza un seguimiento de las asignaciones mediante el flujo de control y reduce el tipo después de cada rama.
function process(x: string | null) {
if (x === null) return;
// x is string here — TypeScript knows null is ruled out
console.log(x.length);
}Ampliación en literales de objeto
Los valores de las propiedades de los literales de objeto también se amplían, a menos que use as const.
const config = { mode: "dark" };
// config.mode: string (widened)
const config2 = { mode: "dark" } as const;
// config2.mode: "dark" (literal)Frescura y ampliación
Cuando asigna un literal de objeto directamente a una variable tipada, TypeScript aplica la comprobación de propiedades excesivas; pero, una vez ampliado a una variable con nombre, esa comprobación deja de aplicarse.
interface Options { timeout: number; }
const opts = { timeout: 3000, retry: true };
// No error — widened type, excess property check skipped
const o: Options = opts;Reducción con el operador in
El operador in reduce los tipos unión de objetos comprobando si existe una propiedad.
type Cat = { meow(): void };
type Dog = { bark(): void };
function speak(animal: Cat | Dog) {
if ("meow" in animal) animal.meow();
else animal.bark();
}Reducción con funciones de aserción
Las funciones de aserción usan tipos de retorno asserts condition para reducir el tipo después de la llamada.
function assertString(val: unknown): asserts val is string {
if (typeof val !== "string") throw new Error("Expected string");
}
const x: unknown = "hi";
assertString(x);
x.toUpperCase(); // OK — narrowed to stringResumen: ampliación frente a reducción
La ampliación hace más generales los tipos inferidos para ofrecer flexibilidad; la reducción transforma un tipo amplio en uno preciso dentro de una rama condicional. Comprender ambos conceptos le ayuda a escribir TypeScript más seguro.
Comprobación rápida
¿Qué declaración evita la ampliación al tipo base?
Lo que ha aprendido
Ahora comprende la ampliación de tipos, es decir, cómo TypeScript hace más generales los tipos inferidos, y la reducción, es decir, cómo las comprobaciones condicionales producen tipos precisos. Use as const para evitar la ampliación y las comprobaciones del flujo de control para reducir uniones de forma segura.
Preguntas frecuentes
¿La lección «Mecánica de ampliación y reducción de tipos» es gratis?
Sí — el texto completo de «Mecánica de ampliación y reducción 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 «Mecánica de ampliación y reducción de tipos»?
Aprenda cómo TypeScript amplía los tipos y cuándo evitarlo. 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 «Mecánica de ampliación y reducción 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
- Mecánica de ampliación y reducción de tipos
- Tipado contextual: inferencia a partir del contexto
- Comprobación de propiedades adicionales y frescura
- Aserciones const y as const