TypeScript 6: что нового и как изменения ломают старый код

TypeScript 6.0 — это не просто очередное обновление с парой новых фич. Это переходный релиз, который готовит почву для революционного TypeScript 7.0 с десятикратным приростом скорости. Но вместе с новыми возможностями приходят изменения, которые могут сломать ваш существующий код.

Почему TypeScript 6.0 — это особенный релиз?

Команда TypeScript работает над полной переписью компилятора на нативный код (язык Go), что даст прирост производительности в 7-10 раз. TypeScript 7.0 с нативным компилятором ожидается в 2026 году, а TypeScript 6.0 служит мостом между текущей версией и будущим.

Это означает, что в версии 6.0:

• Появятся новые возможности языка

• Некоторые старые настройки станут устаревшими (deprecated)

• Изменится поведение по умолчанию для многих опций

• Удалятся совсем старые возможности, которые конфликтуют с будущим

Главная новая фича: управление ресурсами через using.

Самое заметное нововведение в TypeScript 6.0 — это ключевое слово using для явного управления ресурсами (Explicit Resource Management). Это решает одну из самых частых проблем разработчиков: забытые соединения с базами данных, неочищенные обработчики событий и утечки памяти.

Как это работало раньше?

❌ Старый способ

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 {
        // Нужно не забыть закрыть соединения
        await db.close();
        await cache.close();
    }
}

Проблема: легко забыть закрыть соединение, особенно если путей выхода из функции много.

✅ Новый способ с using

async function fetchUserData(userId: string) {
    using db = await connectToDatabase();
    using cache = new RedisConnection();
    
    // Автоматически очистится при выходе из функции
    const user = await db.users.findById(userId);
    await cache.set(`user:${userId}`, user);
    return user;
    // db и cache автоматически закроются здесь
}

Решение: Ресурсы автоматически очищаются при выходе из области видимости!

Где это полезно?

🗄️ Соединения с БД: PostgreSQL, MongoDB, Redis автоматически закроются

📁 Файловые операции: файлы будут закрыты после чтения/записи

⚛️ React компоненты: автоматическая очистка подписок и слушателей

🔒 Любые cleanup операции: временные файлы, locks, транзакции

Улучшенный вывод типов.

TypeScript 6.0 стал умнее понимать контекст и выводить типы. Особенно это заметно при работе с:

• Промисами и async/await: компилятор лучше понимает цепочки асинхронных операций

• Дженериками: меньше нужно явно указывать типы — TypeScript сам догадается

• Условными типами: более точное определение типов в сложных сценариях

TypeScript 5.x

// Требовал явного указания типа
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

// Выводит типы автоматически
const items = await Promise.all([
    fetch('/api/users').then(r => r.json()),
    fetch('/api/posts').then(r => r.json())
]);
// items уже имеет правильный тип!

Breaking Changes: что сломается в вашем коде?

А теперь самое важное — изменения, которые могут сломать существующий код. Давайте разберем каждое подробно.

1. --strict станет дефолтным

Что меняется: Режим строгой проверки типов будет включен по умолчанию.

Что это значит:

• strictNullChecks — нельзя присваивать null или undefined без явного разрешения

• noImplicitAny — нельзя оставлять тип any неявно

• strictFunctionTypes — более строгая проверка типов функций

❌ Как ломается код:

// Раньше работало
function getUser(id: number) {
    return users.find(u => u.id === id); // возвращает User | undefined
}

const user = getUser(1);
console.log(user.name); // Ошибка в TS 6.0! user может быть undefined

✅ Правильно в TS 6.0:

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

Как исправить: Добавьте проверки на null/undefined или используйте optional chaining (?.).

2. Удаление --target es5

Что меняется: Нельзя будет компилировать в ES5. Минимум — ES2015 (ES6).

Почему: ES5 — это JavaScript из 2009 года. Современные браузеры и Node.js давно поддерживают ES6+. Поддержка ES5 замедляет компилятор.

// tsconfig.json
{
    "compilerOptions": {
        "target": "es5" // ❌ Ошибка в TypeScript 6.0!
    }
}

// tsconfig.json
{
    "compilerOptions": {
        "target": "es2015" // ✅ Минимум ES2015
    }
}

Как исправить:

• Измените target на "es2015" или новее

• Если нужна поддержка старых браузеров — используйте Babel для транспиляции после TypeScript

3. Изменения в --moduleResolution

Что меняется: Устаревают старые стратегии разрешения модулей:

• --moduleResolution node (или node10) — удаляется

• Новые рекомендуемые: bundler, node16, nodenext

⚠️ Внимание: Импорты могут перестать работать, если вы используете относительные пути без расширений.

Раньше работало

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

Теперь нужно

// Явно указывать расширение
import { helper } from './utils.js';
// Да, .js даже для .ts файлов!

💡 Почему .js для .ts файлов?

TypeScript следует стандарту ES Modules, где импорты должны быть такими же, как в итоговом JavaScript.

Как исправить:

1. Измените moduleResolution в tsconfig.json

2. Добавьте расширения к импортам

3. Или используйте "bundler" — он более гибкий

4. Удаление --baseUrl

Что меняется: Опция --baseUrl устаревает и будет удалена.

Старый способ

// tsconfig.json
{
    "compilerOptions": {
        "baseUrl": "./src" // ❌ Устарело!
    }
}

// Импорты работали так
import { Button } from 'components/Button';

Новый способ

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

// Теперь импорты выглядят так
import { Button } from '@components/Button';

5. Изменение дефолтного значения types

Что меняется: Поле types по умолчанию будет пустым массивом [] вместо автоматического включения всех типов из node_modules/@types.

// Раньше работало автоматически
import * as express from 'express'; // типы подхватывались автоматически

// В TS 6.0 нужно явно указать
{
    "compilerOptions": {
        "types": ["node", "express", "jest"]
    }
}

💡 Почему это полезно:

Многие проекты случайно подключали сотни неиспользуемых типов, что замедляло компиляцию на 20-50%.

6. rootDir по умолчанию = директория tsconfig.json

Что меняется: rootDir больше не вычисляется автоматически из структуры файлов.

// До TS 6.0: rootDir вычислялся из исходников
// src/
//   app/
//     index.ts
//   utils/
//     helper.ts

// После TS 6.0: rootDir = директория с tsconfig.json
// Нужно явно указать
{
    "compilerOptions": {
        "rootDir": "./src"
    }
}

7. Ключевое слово asserts больше не поддерживается

BREAKING

Что меняется: Ключевое слово asserts было экспериментальным и теперь удаляется, так как оно было добавлено и удалено из спецификации JavaScript.

// ❌ Это больше не работает
import json from './data.json' 
    asserts { type: 'json' };

// ✅ Используйте вместо этого
import json from './data.json';

Как подготовиться к миграции на TypeScript 6.0

Шаг 1: Проверьте свой tsconfig.json

Найдите устаревшие настройки:

{
    "compilerOptions": {
        // ❌ Удалить/заменить
        "target": "es5",
        "moduleResolution": "node",
        "baseUrl": "./src",
        
        // ✅ Добавить явно, если нужно
        "strict": false, // Если хотите отложить включение strict
        "types": ["node", "jest"], // Указать явно
        
        // ✅ Новые рекомендации
        "target": "es2015",
        "moduleResolution": "bundler",
        "paths": {
            "@/*": ["./src/*"]
        }
    }
}

Шаг 2: Обновите импорты

Если используете moduleResolution: "node16" или "nodenext", добавьте расширения:

// Было
import { helper } from './utils';

// Стало
import { helper } from './utils.js';

Шаг 3: Включите strict постепенно

Если вы пока не готовы к полному strict режиму, включайте опции по одной:

{
    "compilerOptions": {
        "strict": false,
        "strictNullChecks": true, // Начните с этого
        // Потом добавляйте остальные по мере готовности
        // "noImplicitAny": true,
        // "strictFunctionTypes": true,
    }
}

Шаг 4: Тестируйте на TypeScript 5.9

TypeScript 5.9 уже показывает предупреждения о том, что устареет в 6.0. Используйте его для подготовки:

npm install -D typescript@5.9

Производительность: почему это важно

Хотя основной прирост скорости придет в TypeScript 7.0, уже в 6.0 есть оптимизации:

⚡ Кэширование промежуточных типов: При работе со сложными библиотеками (Zod, tRPC) компиляция ускоряется

📦 Меньше файлов проверяется: Благодаря изменению types по умолчанию

🚀 Более эффективное разрешение модулей: Новые стратегии быстрее

А в TypeScript 7.0 (который выйдет после 6.0):

• Компиляция быстрее в 10 раз

• Использование памяти снижено в 2 раза

• Загрузка проекта в редакторе с 9.6 секунд до 1.2 секунды

Заключение.

TypeScript 6.0 — это важный шаг в эволюции языка. Да, он принесет breaking changes, но все они направлены на:

• 🛡️ Повышение безопасности кода (через strict)

• ⚡ Улучшение производительности (через оптимизации и подготовку к TS 7.0)

• 🎯 Соответствие современным стандартам (через обновление модульной системы)

Ключевое слово using решает реальную проблему управления ресурсами. Улучшенный вывод типов делает код чище. А подготовка к TypeScript 7.0 обещает революционный прирост скорости.

Да, миграция потребует усилий, особенно если у вас большой проект. Но результат того стоит: более безопасный, быстрый и современный код.

Это и многое другое можно изучить в Кодике!

Мы разбираем все подробно — от основ до продвинутых концепций — и закрепляем знания практическими заданиями.

А если нужна помощь или хочется обсудить код — у нас уже больше 2000 единомышленников в активном телеграм-канале, где всегда помогут и подскажут! 🚀