0Pricing
TypeScript Academy · Lección

TypeScript 5.1-5.2: mejoras en la inferencia

Explore la independencia de tipos entre setters y getters y las declaraciones using.

TypeScript 5.1-5.2: mejoras en la inferencia es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 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.

Introducción a TypeScript 5.1

TypeScript 5.1 (publicado en junio de 2023) mejoró la independencia de tipos entre setters y getters, la flexibilidad del tipo de elemento JSX, los cursores vinculados en los editores y las optimizaciones de rendimiento.

// npm install typescript@5.1

Independencia de tipos entre setters y getters

Antes de la versión 5.1, el setter y el getter debían utilizar el mismo tipo. Ahora, un getter puede devolver un tipo más amplio que el que acepta el setter, lo que resulta útil para patrones de coerción.

class Temperature {
  get celsius(): string { return this._c + "°C"; } // string
  set celsius(value: string | number) {             // string | number
    this._c = Number(value);
  }
  private _c = 0;
}

undefined como hijos de JSX

TS 5.1 permite que los componentes devuelvan directamente undefined (además de null) desde su función de renderizado, en consonancia con el comportamiento de React 18.

// TS 5.1+: OK
function Widget(): undefined { return undefined; }
// Before 5.1: had to return null or JSX element

Flexibilidad del tipo de elemento JSX

La nueva restricción JSX.ElementType ofrece más flexibilidad para las fábricas JSX personalizadas, lo que resulta útil en entornos que no usan React.

// Custom JSX element types supported more naturally in 5.1

Descripción general de TypeScript 5.2

TypeScript 5.2 (publicado en agosto de 2023) introdujo las declaraciones using (gestión explícita de recursos), los metadatos de decoradores y los métodos de copia de arrays.

// npm install typescript@5.2

Declaraciones using

using implementa la propuesta de gestión explícita de recursos: el método [Symbol.dispose]() del recurso se llama cuando este sale de ámbito.

// Requires lib: ["es2022", "esnext.disposable"]
function getConnection(): Disposable {
  const conn = openDb();
  return { [Symbol.dispose]() { conn.close(); } };
}

{
  using conn = getConnection();
  // conn.close() called automatically at block end
}

await using para la eliminación asíncrona

await using funciona como using, pero llama a un método asíncrono [Symbol.asyncDispose](), lo que permite realizar la limpieza de forma asíncrona.

async function run() {
  await using db = await connectDb();
  // db[Symbol.asyncDispose]() called on exit
}

Metadatos de decoradores

TS 5.2 implementa la propuesta de metadatos de decoradores de TC39, lo que permite que los decoradores adjunten metadatos mediante Symbol.metadata.

function meta(value: string) {
  return (_: unknown, ctx: DecoratorContext) => {
    ctx.metadata[ctx.name] = value;
  };
}

@meta("service")
class MyService {}
console.log((MyService as any)[Symbol.metadata]); // { "MyService": "service" }

Métodos de copia de arrays

TS 5.2 añadió tipos para Array.prototype.toSorted, toReversed, toSpliced y with: operaciones inmutables para arrays de ES2023.

const arr = [3, 1, 2];
const sorted = arr.toSorted(); // [1, 2, 3] — new array, arr unchanged
const reversed = arr.toReversed(); // [2, 1, 3]

Uso de using en tsconfig para 5.2

Para usar declaraciones using, incluya la biblioteca esnext.disposable en su tsconfig.

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022", "ESNext.Disposable"]
  }
}

Resumen: TS 5.1-5.2

TS 5.1: tipos independientes para getters y setters, y retornos JSX con undefined. TS 5.2: declaraciones using para la limpieza automática de recursos, metadatos de decoradores y tipos para métodos inmutables de copia de arrays.

Comprobación rápida

¿Qué hace la declaración using en TypeScript 5.2?

Lo que ha aprendido

TS 5.1 incorporó tipos independientes para getters y setters, y retornos JSX con undefined. TS 5.2 añadió declaraciones using para la gestión automática de recursos, metadatos de decoradores y tipos para métodos inmutables de arrays de ES2023.

Preguntas frecuentes

¿La lección «TypeScript 5.1-5.2: mejoras en la inferencia» es gratis?

Sí — el texto completo de «TypeScript 5.1-5.2: mejoras en la inferencia» 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 «TypeScript 5.1-5.2: mejoras en la inferencia»?

Explore la independencia de tipos entre setters y getters y las declaraciones using. 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 2 de 4.

¿Cuánto tiempo toma la lección «TypeScript 5.1-5.2: mejoras en la inferencia»?

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. TypeScript 5.0: decoradores estándar y parámetros de tipo const
  2. TypeScript 5.1-5.2: mejoras en la inferencia
  3. TypeScript 5.3-5.4: nueva reducción de tipos y NoInfer
  4. TypeScript 5.5+: declaraciones aisladas y novedades
← Volver a TypeScript Academy