TypeScript 6: qué hay de nuevo y cómo los cambios rompen el código anterior

TypeScript 6.0 no es solo otra actualización con un par de características nuevas. Es lanzamiento de transición, que prepara el terreno para el revolucionario TypeScript 7.0 con un aumento de velocidad de diez veces. Pero junto con las nuevas características vienen cambios que pueden romper tu código existente.

¿Por qué TypeScript 6.0 es una versión especial?

El equipo de TypeScript está trabajando en una reescritura completa del compilador a código nativo (lenguaje Go), lo que dará un aumento de rendimiento de 7 a 10 veces. Se espera que TypeScript 7.0 con compilador nativo esté disponible en 2026, y TypeScript 6.0 sirve como puente entre la versión actual y el futuro.

Esto significa que en la versión 6.0:

• Aparecerán nuevas posibilidades del lenguaje

• Algunas configuraciones antiguas quedarán obsoletas (deprecated)

• Cambiará el comportamiento predeterminado de muchas opciones

• Se eliminarán las funciones muy antiguas que entran en conflicto con el futuro

Nueva característica principal: gestión de recursos mediante using.

La innovación más notable en TypeScript 6.0 es la palabra clave using para gestión explícita de recursos (Explicit Resource Management). Esto resuelve uno de los problemas más comunes de los desarrolladores: conexiones de base de datos olvidadas, manejadores de eventos sin limpiar y fugas de memoria.

¿Cómo funcionaba antes?

❌ Método antiguo

async function fetchUserData(userId: string) {
    const db = await connectToDatabase();
    const cache = new RedisConnection();
    
    try {
        const user = await db.users.findById(userId);
        await cache.set(`user:${userId}`, user);
        return user;
    } finally {
        // No olvides cerrar las conexiones
        await db.close();
        await cache.close();
    }
}

Problema: es fácil olvidar cerrar la conexión, especialmente si hay muchas formas de salir de la función.

✅ Nueva forma con using

async function fetchUserData(userId: string) {
    using db = await connectToDatabase();
    using cache = new RedisConnection();
    
    // Se borrará automáticamente al salir de la función
    const user = await db.users.findById(userId);
    await cache.set(`user:${userId}`, user);
    return user;
    // db y cache se cerrarán automáticamente aquí
}

Solución: ¡Los recursos se borran automáticamente al salir del área de visibilidad!

¿Dónde es útil?

🗄️ Conexiones con la base de datos: PostgreSQL, MongoDB, Redis se cerrarán automáticamente

📁 Operaciones de archivo: los archivos se cerrarán después de leer/escribir

⚛️ Componentes de React: limpieza automática de suscripciones y oyentes

🔒 Cualquier operación de limpieza: archivos temporales, bloqueos, transacciones

Salida de tipos mejorada.

TypeScript 6.0 se ha vuelto más inteligente para comprender el contexto y mostrar los tipos. Esto es especialmente notable cuando se trabaja con:

• Promesas y async/await: el compilador comprende mejor las cadenas de operaciones asíncronas

• Genéricos: menos necesidad de especificar explícitamente los tipos: TypeScript lo adivinará por sí mismo

• Tipos condicionales: definición más precisa de los tipos en escenarios complejos

TypeScript 5.x

// Requería una indicación explícita del tipo
const items = await Promise.all([
    fetch('/api/users').then(r => r.json() as User[]),
    fetch('/api/posts').then(r => r.json() as Post[])
]);

TypeScript 6.0

// Muestra los tipos automáticamente
const items = await Promise.all([
    fetch('/api/users').then(r => r.json()),
    fetch('/api/posts').then(r => r.json())
]);
// ¡items ya tiene el tipo correcto!

Breaking Changes: ¿qué se romperá en tu código?

Y ahora lo más importante: los cambios que pueden romper el código existente. Analicemos cada uno en detalle.

1. --strict se convertirá en el valor predeterminado

Qué cambia: El modo de comprobación estricta de tipos se activará de forma predeterminada.

¿Qué significa esto?

• strictNullChecks — no se puede asignar null o undefined sin permiso explícito

• noImplicitAny — no se puede dejar el tipo any implícito

• strictFunctionTypes - verificación de tipo de función más estricta

❌ Cómo se rompe el código:

// Antes funcionaba
function getUser(id: number) {
    return users.find(u => u.id === id); // devuelve User | undefined
}

const user = getUser(1);
console.log(user.name); // ¡Error en TS 6.0! El usuario puede estar indefinido

✅ Correcto en TS 6.0:

const user = getUser(1);
if (user) {
    console.log(user.name); // OK
}
// o
console.log(user?.name); // OK, optional chaining

Cómo solucionarlo: Añade comprobaciones a null/undefined o usa optional chaining (?.).

2. Eliminación --target es5

Qué cambia: No se podrá compilar en ES5. Mínimo — ES2015 (ES6).

Por qué: ES5 es JavaScript de 2009. Los navegadores modernos y Node.js han sido compatibles con ES6+ durante mucho tiempo. La compatibilidad con ES5 ralentiza el compilador.

// tsconfig.json
{
    "compilerOptions": {
        "target": "es5" // ❌ ¡Error en TypeScript 6.0!
    }
}

// tsconfig.json
{
    "compilerOptions": {
        "target": "es2015" // ✅ Mínimo ES2015
    }
}

Cómo solucionarlo:

• Cambie target a "es2015" o posterior

• Si necesita soporte para navegadores antiguos, use Babel para la transcripción después de TypeScript

3. Cambios en --moduleResolution

Qué cambia: Las viejas estrategias de resolución de módulos se están volviendo obsoletas:

• --moduleResolution node (o node10) — se elimina

• Nuevos recomendados: bundler, node16, nodenext

⚠️ Atención: Las importaciones pueden dejar de funcionar si utilizas rutas relativas sin extensiones.

Antes funcionaba

// Con --moduleResolution node
import { helper } from './utils';

Ahora necesitas

// Indicar explícitamente la extensión
import { helper } from './utils.js';
// Sí, .js incluso para archivos .ts!

💡 ¿Por qué .js para archivos .ts?

TypeScript sigue el estándar de los módulos ES, donde las importaciones deben ser las mismas que en el JavaScript final.

Cómo solucionarlo:

1. Cambia moduleResolution en tsconfig.json

2. Añadir extensiones a las importaciones

3. O usa "bundler" — es más flexible

4. Eliminación --baseUrl

Qué cambia: La opción --baseUrl está obsoleta y se eliminará.

Método antiguo

// tsconfig.json
{
    "compilerOptions": {
        "baseUrl": "./src" // ❌ ¡Obsoleto!
    }
}

// Las importaciones funcionaban así
import { Button } from 'components/Button';

Nuevo método

// tsconfig.json
{
    "compilerOptions": {
        "paths": {
            "@components/*": ["./src/components/*"],
            "@utils/*": ["./src/utils/*"]
        }
    }
}

// Ahora las importaciones se ven así
import { Button } from '@components/Button';

5. Cambio del valor predeterminado de types

Qué cambia: El campo types por defecto será una matriz vacía [] en lugar de incluir automáticamente todos los tipos de node_modules/@types.

// Antes funcionaba automáticamente
import * as express from 'express'; // los tipos se detectaron automáticamente

// En TS 6.0, debe especificarse explícitamente
{
    "compilerOptions": {
        "types": ["node", "express", "jest"]
    }
}

💡 Por qué es útil:

Muchos proyectos incluían accidentalmente cientos de tipos no utilizados, lo que ralentizaba la compilación en un 20-50 %.

6. rootDir predeterminado = directorio tsconfig.json

Qué cambia: rootDir ya no se calcula automáticamente a partir de la estructura del archivo.

// Antes de TS 6.0: rootDir se calculaba a partir de los orígenes
// src/
//   app/
//     index.ts
//   utils/
//     helper.ts

// Después de TS 6.0: rootDir = directorio con tsconfig.json
// Debe especificarse explícitamente
{
    "compilerOptions": {
        "rootDir": "./src"
    }
}

7. La palabra clave asserts ya no es compatible

BREAKING

Qué cambia: La palabra clave asserts era experimental y ahora se elimina, ya que se agregó y eliminó de la especificación de JavaScript.

// ❌ Esto ya no funciona
import json from './data.json' 
    asserts { type: 'json' };

// ✅ Utiliza en su lugar
import json from './data.json';

Cómo prepararse para la migración a TypeScript 6.0

Paso 1: Comprueba tu tsconfig.json

Encuentre la configuración obsoleta:

{
    "compilerOptions": {
        // ❌ Eliminar/reemplazar
        "target": "es5",
        "moduleResolution": "node",
        "baseUrl": "./src",
        
        // ✅ Añadir explícitamente si es necesario
        "strict": false, // Si desea posponer la inclusión de strict
        "types": ["node", "jest"], // Especificar explícitamente
        
        // ✅ Nuevas recomendaciones
        "target": "es2015",
        "moduleResolution": "bundler",
        "paths": {
            "@/*": ["./src/*"]
        }
    }
}

Paso 2: Actualizar las importaciones

Si utilizas moduleResolution: "node16" o "nodenext", añade las extensiones:

// Antes
import { helper } from './utils';

// Ahora
import { helper } from './utils.js';

Paso 3: Activa strict gradualmente

Si aún no estás listo para el modo strict completo, activa las opciones de una en una:

{
    "compilerOptions": {
        "strict": false,
        "strictNullChecks": true, // Empieza por aquí
        // Luego añade el resto a medida que estén listos
        // "noImplicitAny": true,
        // "strictFunctionTypes": true,
    }
}

Paso 4: Prueba en TypeScript 5.9

TypeScript 5.9 ya muestra advertencias de que quedará obsoleto en 6.0. Úsalo para prepararte:

npm install -D typescript@5.9

Productividad: por qué es importante

Aunque el principal aumento de velocidad vendrá en TypeScript 7.0, ya en 6.0 hay optimizaciones:

⚡ Almacenamiento en caché de tipos intermedios: Al trabajar con bibliotecas complejas (Zod, tRPC), la compilación se acelera

📦 Se comprueban menos archivos: Gracias al cambio types por defecto

🚀 Resolución de módulos más eficiente: Nuevas estrategias más rápidas

Y en TypeScript 7.0 (que se lanzará después de 6.0):

• Compilación más rápida en 10 veces

• El uso de la memoria se ha reducido en 2 veces

• Carga del proyecto en el editor con 9,6 segundos a 1,2 segundos

Conclusión.

TypeScript 6.0 es un paso importante en la evolución del lenguaje. Sí, traerá cambios importantes, pero todos están dirigidos a:

• 🛡️ Aumento de la seguridad del código (a través de strict)

• ⚡ Mejora del rendimiento (mediante optimizaciones y preparación para TS 7.0)

• 🎯 Cumplimiento de los estándares modernos (mediante la actualización del sistema modular)

La palabra clave using resuelve el problema real de la gestión de recursos. La salida de tipo mejorada hace que el código sea más limpio. Y la preparación para TypeScript 7.0 promete un aumento revolucionario en la velocidad.

Sí, la migración requerirá esfuerzo, especialmente si tienes un proyecto grande. Pero el resultado vale la pena: un código más seguro, rápido y moderno.

Esto y mucho más se puede estudiar en Codice!

Analizamos todo en detalle, desde los conceptos básicos hasta los avanzados, y consolidamos el conocimiento con tareas prácticas.

Y si necesitas ayuda o quieres discutir el código, ya tenemos más 2000 personas de ideas afines en canal de Telegram activo, ¡donde siempre te ayudarán y te aconsejarán! 🚀