> Почему async функция возвращает Promise (JavaScript)

Короткий ответ

async функция возвращает Promise, потому что это её фундаментальный контракт в JavaScript: она всегда оборачивает результат в Promise, чтобы обеспечить единообразную работу с асинхронным кодом. Это позволяет использовать await внутри функции и гарантирует, что вызывающий код может обработать и успешное завершение, и ошибку через стандартные методы then/catch или try/catch с await. Promise - это механизм, который делает асинхронность управляемой и предсказуемой.

Подробное объяснение

Спецификация ECMAScript определяет, что async функция всегда возвращает Promise, независимо от того, что возвращается в теле. Это сделано для консистентности: если бы функция могла возвращать и обычное значение, и Promise, вызывающий код должен был бы проверять тип результата. Единый контракт упрощает композицию и абстракции.

Когда async функция выполняется:

• если тело завершается без ошибок, возвращаемое значение оборачивается в Promise.resolve(value)
• если тело выбрасывает исключение, оно превращается в Promise.reject(error)
• если тело возвращает Promise, он "разворачивается" - внешний Promise принимает его состояние

Это поведение реализовано на уровне движка (V8, SpiderMonkey и т.д.), а не через явный return new Promise(...).

Ключевой момент: await внутри async функции работает только потому, что функция уже возвращает Promise. await приостанавливает выполнение функции, но не блокирует event loop - управление возвращается в цикл событий, а когда Promise разрешается, выполнение продолжается с сохранённого состояния.

На практике

Для senior-разработчика важно понимать, что async/await - это синтаксический сахар над Promise. Это означает:

• можно смешивать async функции с цепочками .then() без проблем
• ошибки в async функциях всегда становятся rejected Promise, даже если не использовать try/catch
• async функции не выполняются "параллельно" - они выполняются последовательно, если не использовать Promise.all или другие комбинаторы
• возврат Promise из async функции не создаёт лишнюю обёртку - движок оптимизирует это

На практике это влияет на:

• обработку ошибок: try/catch внутри async функции перехватывает и синхронные, и асинхронные ошибки
• производительность: лишний await на каждый вызов добавляет микротаск, что при очень частых вызовах может быть заметно
• тестирование: async функции легко тестировать через await в тестах

Пример кода

JAVASCRIPT
// Базовый случай: значение оборачивается в Promise
async function getNumber() {
  return 42;
}
getNumber().then(console.log); // 42

// Исключение становится rejected Promise
async function throwError() {
  throw new Error('boom');
}
throwError().catch(err => console.log(err.message)); // 'boom'

// Возврат Promise не создаёт двойную обёртку
async function passthrough() {
  return Promise.resolve('value');
}
passthrough().then(console.log); // 'value'

// Смешивание с .then()
async function fetchData() {
  const response = await fetch('/api/data');
  return response.json();
}
fetchData().then(data => console.log(data));

// Важно: async функция не блокирует event loop
async function nonBlocking() {
  console.log('start');
  await Promise.resolve();
  console.log('end');
}
console.log('sync');
nonBlocking();
// Вывод: 'sync', 'start', 'end'

Как отвечать на собеседовании

Начните с краткого определения, затем объясните механизм: движок оборачивает результат в Promise, чтобы обеспечить единый интерфейс. Подчеркните, что это не случайность, а дизайн-решение для консистентности. Упомяните, что await работает только внутри async функции именно потому, что функция возвращает Promise.

Затем покажите понимание глубины: объясните, что async/await - это синтаксический сахар, и что ошибки всегда становятся rejected Promise. Если спросят про производительность, скажите, что лишний await добавляет микротаск, но это редко критично.

Хорошо добавить пример с event loop: как await приостанавливает функцию, но не блокирует поток. Это покажет, что вы понимаете, как работает асинхронность в JavaScript на уровне движка.

Что проверяет интервьюер

Интервьюер проверяет:

• понимание фундаментальной модели асинхронности в JavaScript
• знание того, что async/await - это не магия, а обёртка над Promise
• умение объяснить поведение ошибок и их обработку
• понимание event loop и микротасков
• способность связать теорию с практикой (смешивание с .then(), тестирование)

Для senior-уровня важно, чтобы вы не просто знали факт, а могли объяснить, почему это так, и какие последствия это имеет для архитектуры и производительности.

Типичные ошибки

• утверждение, что async функция "возвращает Promise, потому что так решили" - без объяснения причин
• путаница между Promise.resolve(value) и new Promise(resolve => resolve(value)) - они эквивалентны, но первое короче
• мнение, что await блокирует поток - это не так, он приостанавливает только текущую функцию
• игнорирование того, что ошибки в async функциях всегда становятся rejected Promise, даже если нет try/catch
• попытка вернуть Promise из async функции через return new Promise(...) - это избыточно, движок сделает это сам