Guía Práctica de Características Nuevas de TypeScript 5 — Operador Satisfies y Decoradores

Resumen Clave TypeScript 5.0–5.3 (2026) introduce operador satisfies para validación de tipo sin asignación, decoradores estables para inyección de dependencia, const type parameters para genéricos constantes, y mejoras en JSDoc. Satisfies es la característica más importante, permitiendo verificar cumplimiento de tipo mientras se preserva tipo literal.

Respuesta Clave: Satisfies = verificar tipo sin asumir tipo más amplio. Decoradores = inyección de dependencia real en TypeScript.

Operador Satisfies — La Característica Más Importante

Antes de TypeScript 5 (Problema)

interface User { name: string; age: number; }

const user: User = { name: "Alice", age: 30, // ❌ Error — campo extra no permitido email: "[email protected]", };

Problema: Si escribes : User, pierdes el tipo literal de las propiedades:

const user: User = { name: "Alice", age: 30 }; console.log(user.name); // Tipo: string (genérico) // ¿No puedes hacer: typeof user.name === "Alice" para type guard?

Después de TypeScript 5 (Solución — Satisfies)

const user = { name: "Alice", age: 30, } satisfies User;

console.log(user.name); // Tipo: "Alice" (literal preservado) // ✅ Ahora puedes hacer: typeof user.name === "Alice"

Ventajas de Satisfies

1. Verifica Cumplimiento — Asegura que el objeto implementa la interfaz 2. Preserva Tipo Literal — El tipo de cada propiedad se mantiene literal ("Alice", no string) 3. Evita Sobre-asignación — No permite campos extra 4. Mejor Inferencia — El compilador infiere tipos más específicos

Casos de Uso Prácticos

#### Caso 1: Configuración de Aplicación

interface Config { apiUrl: string; port: number; debug: boolean; }

const config = { apiUrl: "https://api.example.com", port: 3000, debug: process.env.NODE_ENV === "development", } satisfies Config;

// Beneficio: Puedes hacer union types sobre literal type ApiUrl = typeof config.apiUrl; // "https://api.example.com"

#### Caso 2: Rutas Tipadas

interface Route { path: string; method: "GET" | "POST"; handler: (req: any) => any; }

const routes = [ { path: "/users", method: "GET", handler: () => "list users", }, { path: "/users/:id", method: "POST", handler: (req) => "create user", }, ] satisfies Route[];

// Beneficio: Autocomplete en método + validación routes[0].method; // Tipo: "GET" (literal)

#### Caso 3: Registro de Constantes

interface LogLevel { level: "debug" | "info" | "warn" | "error"; color: "blue" | "green" | "yellow" | "red"; }

const LOG_LEVELS = { DEBUG: { level: "debug", color: "blue" }, INFO: { level: "info", color: "green" }, WARN: { level: "warn", color: "yellow" }, ERROR: { level: "error", color: "red" }, } satisfies Record;

// Beneficio: Acceso tipado a propiedades anidadas console.log(LOG_LEVELS.DEBUG.level); // Tipo: "debug"

Const Type Parameters — Genéricos Constantes

Problema Anterior

function identity(x: T): T { return x; }

const result = identity("hello"); // result tiene tipo: string (no "hello")

Solución — Const Type Parameter

function identity(x: T): T { return x; }

const result = identity("hello"); // result tiene tipo: "hello" (literal preservado)

Caso de Uso: Builder Pattern

function createObject>(obj: T): T { return obj; }

const config = createObject({ name: "MyApp", version: "1.0", debug: true, });

// Tipo: { readonly name: "MyApp"; readonly version: "1.0"; readonly debug: true }

---

Mejoras en JSDoc — Soporte de Tipos en Comentarios

Esta imagen ayuda a comprobar el punto anterior con un ejemplo visual.

JSDoc Tipo Union

/* Calcula la suma de dos números @param {number | string} a - Primer número o cadena numérica @param {number | string} b - Segundo número o cadena numérica @returns {number} La suma / function add(a, b) { return Number(a) + Number(b); }

JSDoc Genéricos

/* Filtra matriz por predicado @template T @param {T[]} arr - Array a filtrar @param {(item: T) => boolean} predicate - Función de filtro @returns {T[]} Array filtrado */ function filter(arr, predicate) { return arr.filter(predicate); }

---

Mejoras en Inferencia de Tipos

Asignación más Inteligente

// TypeScript 5 infiere tipos más precisos const obj = { a: 10, b: "hello", c: () => "world", };

// Tipos: // a: number (antes sería type number) // b: string // c: () => string

Mejor Narrowing en Discriminados

type Shape =

function area(shape: Shape) { if (shape.type === "circle") { // shape es { type: "circle"; radius: number } return Math.PI shape.radius * 2; }

---

Preguntas Frecuentes

P1: ¿Cuándo usar satisfies vs :?

R: Usa satisfies cuando necesites preservar tipos literales. Usa : cuando necesites aceptar cualquier valor del tipo.

// satisfies: Preserva "Alice" const user1 = { name: "Alice" } satisfies User; // Tipo de name: "Alice"

// : Amplía a string const user2: User = { name: "Alice" }; // Tipo de name: string

P2: ¿Los decoradores están estables?

R: Sí, desde TypeScript 5.0. Requiere experimentalDecorators: false en tsconfig.json (el predeterminado en TS 5+).

P3: ¿Cuál es el rendimiento de const type parameters?

R: Sin costo en tiempo de ejecución. Solo afecta la compilación (mejora la inferencia).

P4: ¿Debo migrar mi código existente a satisfies?

R: No urgente, pero recomendado para nuevas configuraciones y objetos constantes donde quieras preservar tipos literales.

P5: ¿JSDoc es mejor que anotaciones de tipo?

R: No. JSDoc sin TypeScript es más débil. Usa JSDoc solo si no puedes usar TypeScript en un archivo.

P6: ¿Cuál es la nueva característica más importante para productividad?

R: Satisfies. Reduce el uso de type assertions y type guards innecesarios.