Такие фичи упрощают код, особенно в серверных приложениях и при работе с сетевыми потоками. Нет нужды вручную обрабатывать очистку - runtime сам вызовет методы dispose. В итоге код становится чище и надежнее, минимизируя риски ошибок.

Что такое using и зачем оно нужно

Ключевое слово using объявляет блоковую переменную, которая автоматически очищается синхронно при выходе из скоупа. Оно работает с объектами, реализующими Symbol.dispose - специальный метод для логики очистки. Раньше разработчики полагались на try-finally, чтобы гарантировать закрытие ресурсов вроде файлов или сокетов. Теперь using берет это на себя, даже если внутри блока выбросится ошибка.

Представьте типичный сценарий: чтение файла или подключение к БД. Без using вы пишете acquireResource, используете, а потом в finally вызываете close. Если забудете или код усложнится, ресурс утечет. Using упрощает это до одного блока, где очистка гарантирована. Это особенно полезно в асинхронном коде, где ошибки могут прерывать выполнение непредсказуемо.

Вот базовый пример с файлом:

{
  using fileHandle = openFile('data.txt');
  const data = fileHandle.read();
  // Автоматический вызов fileHandle[Symbol.dispose]()
}

• Синхронная очистка: Symbol.dispose вызывается сразу при выходе из блока.
• Обработка ошибок: Даже при throw ресурсы освобождаются.
• Блоковая видимость: Переменная доступна только внутри {}.

await using для асинхронных ресурсов

await using расширяет идею на асинхронные операции, вызывая Symbol.asyncDispose и дожидаясь его завершения. Это критично для сетевых потоков, ReadableStream или БД-соединений, где закрытие требует await. Без него асинхронная очистка в finally усложняет код и повышает риск утечек при раннем return.

Возьмем пример с fetch и чтением потока:

const response = await fetch('https://api.example.com/data');
{
  await using reader = response.body.getReader();
  while (true) {
    const {done, value} = await reader.read();
    if (done) break;
    // Обработка value
  }
  // Автоматический reader.releaseLock()
}

Runtime гарантирует последовательную очистку нескольких ресурсов в обратном порядке объявления. Если один dispose кинет ошибку, остальные все равно выполнятся.

Преимущества в сравнении с try-finally:

• Последовательность: Ресурсы чистятся по порядку, await между ними.
• Контейнеры: Поддержка DisposableStack для нескольких ресурсов.
• Ошибки: Не прерывают цепочку dispose других объектов.

Контейнеры DisposableStack и AsyncDisposableStack

Для управления несколькими ресурсами вводятся DisposableStack и AsyncDisposableStack. Это стековые контейнеры: добавляете ресурсы через push, а при dispose они чистятся в обратном порядке. Идеально для сценариев вроде открытия файла + соединения с БД + сокета.

Сравните ручной подход и новый:

// Старый способ
const stack = new DisposableStack();
stack.push(openFile('file.txt'));
stack.push(db.connect());
try {
  // Работа
} finally {
  await stack.disposeAsync();
}

Стек сам отслеживает зависимости - сначала закроется последний добавленный. Это предотвращает проблемы, когда внешний ресурс зависит от внутреннего.

Ключевые возможности:

• push/disposeAsync: Добавление и массовая очистка.
• Обратный порядок: Гарантия корректного закрытия зависимостей.
• Интеграция с using: Можно комбинировать в блоках.

Практические нюансы и совместимость

Объекты для using должны иметь Symbol.dispose или Symbol.asyncDispose. Браузеры и Node.js 22+ поддерживают нативно, TypeScript - с 5.4. Не работает с let/var - только using объявления. Null/undefined не вызовут dispose.

Пример с условным ресурсом:

await using resource = isReady() ? getResource() : undefined;
resource?.doWork();
// Без дублирования кода

• Поддержка в V8: Полная в новых версиях.
• Ошибки dispose: Ловятся отдельно, не ломают цепочку.
• Генераторы: Работает с async generators.

Ресурсы, которые меняют правила игры

Using и контейнеры радикально упрощают жизнь с файлами, соединениями и стримами в JS. Код короче, надежнее, без boilerplate. Остается место для кастомных dispose в библиотеках. Дальше ждем примеров в фреймворках вроде Node или Deno.