Что возвращает функция с async?

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

Функция, объявленная с ключевым словом async, всегда возвращает Promise. Даже если внутри функции используется обычное значение, оно будет автоматически обёрнуто в разрешённый (resolved) Promise.

async function example() {
  return 42; // Фактически возвращает Promise.resolve(42)
}

const result = example();
console.log(result); // Promise {<fulfilled>: 42}
console.log(result instanceof Promise); // true

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

Механизм работы async-функций

Когда JavaScript-движок видит ключевое слово async перед функцией, он делает следующее:

1. Автоматическая обёртка в Promise: Любое возвращаемое значение преобразуется в Promise.
2. Обработка исключений: Все синхронные и асинхронные ошибки преобразуются в отклонённые (rejected) промисы.

// Пример с разными возвращаемыми значениями
async function differentReturns() {
  // Примитив
  const num = await Promise.resolve(10);
  
  // Объект
  if (num > 5) {
    return { data: num, status: 'ok' };
  }
  
  // Даже undefined возвращается как Promise
  // Неявно: return undefined;
}

const promise1 = differentReturns();
promise1.then(data => console.log(data)); // { data: 10, status: 'ok' }

Что происходит с различными возвращаемыми значениями

1. Примитивные значения

async function getNumber() {
  return 42; // → Promise.resolve(42)
}

async function getString() {
  return 'hello'; // → Promise.resolve('hello')
}

2. Объекты и массивы

async function getUser() {
  return { id: 1, name: 'John' }; // → Promise.resolve({id: 1, name: 'John'})
}

async function getList() {
  return [1, 2, 3]; // → Promise.resolve([1, 2, 3])
}

3. Уже существующие Promise

async function fetchData() {
  // Если возвращается Promise, он не оборачивается повторно
  return fetch('https://api.example.com/data');
  // Тоже самое, что: return Promise.resolve(fetch(...))
}

4. Ошибки и исключения

async function mightFail() {
  throw new Error('Something went wrong');
  // → Promise.reject(new Error('Something went wrong'))
}

async function asyncError() {
  await Promise.reject('Async error');
  // → Promise.reject('Async error')
}

Практические примеры использования

Обработка результатов

async function processUserData(userId) {
  const response = await fetch(`/api/users/${userId}`);
  const data = await response.json();
  
  // Модифицируем данные
  data.processed = true;
  data.timestamp = new Date();
  
  return data; // Автоматически обёрнуто в Promise
}

// Использование
processUserData(123)
  .then(user => console.log('Обработан:', user))
  .catch(error => console.error('Ошибка:', error));

Композиция async-функций

async function getPostWithComments(postId) {
  const post = await fetchPost(postId); // Возвращает Promise
  const comments = await fetchComments(postId); // Возвращает Promise
  
  return {
    ...post,
    comments,
    totalComments: comments.length
  };
}

// Поскольку все async-функции возвращают Promise,
// их можно комбинировать
async function getFullData() {
  const [user, posts] = await Promise.all([
    getUser(1),    // async-функция
    getPosts(1)    // async-функция
  ]);
  
  return { user, posts };
}

Важные особенности

1. Даже пустая async-функция возвращает Promise

async function empty() {}
// Возвращает: Promise.resolve(undefined)

1. Return await — обычно избыточно

// НЕ рекомендуется (но имеет особые случаи использования)
async function example() {
  return await somePromise;
}

// Лучше
async function example() {
  return somePromise;
}

1. Обработка ошибок через try/catch

async function safeFetch() {
  try {
    const response = await fetch('invalid-url');
    return await response.json();
  } catch (error) {
    // Ошибка преобразуется в rejected Promise
    console.error('Fetch failed:', error);
    throw error; // Прокидываем ошибку дальше
  }
}

Когда это особенно полезно

• Упрощение цепочек Promise: Вместо .then() цепочек используем последовательные await
• Единообразная обработка ошибок: Один try/catch блок для синхронных и асинхронных ошибок
• Читаемость кода: Асинхронный код выглядит почти как синхронный
• Интеграция с современными API: Многие современные Web API и библиотеки используют async/await

Итог

async функция — это синтаксический сахар над Promise, который:

• Всегда возвращает Promise
• Позволяет использовать await внутри
• Автоматически оборачивает возвращаемые значения в Promise
• Преобразует исключения в rejected Promise

Это делает асинхронный код более чистым, читаемым и легко поддерживаемым, сохраняя всю мощь Promise-based подхода.