Что возвращает асинхронная функция, в которой нет Return?

Что возвращает асинхронная функция, в которой нет Return

Это важный вопрос, который показывает понимание того, как работают асинхронные функции в JavaScript. Ответ простой, но критичен для правильного программирования.

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

Асинхронная функция без явного return всегда возвращает Promise, который разрешается со значением undefined.

Объяснение

Любая функция, объявленная с ключевым словом async, автоматически возвращает Promise. Это одно из главных свойств async функций:

async function noReturn() {
  console.log('Hello');
}

const result = noReturn();
console.log(result); // Promise { <pending> }

result.then(value => {
  console.log('Resolved with:', value); // Resolved with: undefined
});

Promise разрешается со значением undefined

Если в async функции нет явного return, то Promise разрешится со значением undefined:

async function example() {
  console.log('Function is running');
  // Нет return
}

example().then(value => {
  console.log('Value:', value); // Value: undefined
  console.log('Type:', typeof value); // Type: undefined
});

Как это работает под капотом

Когда ты используешь async, JavaScript автоматически оборачивает возвращаемое значение (или undefined, если return нет) в Promise:

// Эти две функции эквивалентны по поведению:

// Версия 1: с async
async function asyncVersion() {
  console.log('Running');
}

// Версия 2: эквивалент без async
function promiseVersion() {
  return Promise.resolve(undefined);
}

// Обе возвращают Promise, разрешаемый со значением undefined

С явным return

Если функция возвращает значение, Promise разрешится с этим значением:

async function withValue() {
  return 42;
}

withValue().then(value => {
  console.log(value); // 42
});

С return без значения

Если функция содержит return без значения, Promise также разрешится с undefined:

async function withEmptyReturn() {
  console.log('Running');
  return; // То же самое, что вообще нет return
}

withEmptyReturn().then(value => {
  console.log('Value:', value); // Value: undefined
});

Практические примеры

Пример 1: Функция с побочными эффектами

async function fetchAndLog() {
  const data = await fetch('/api/users');
  console.log(data);
  // Нет return, поэтому вернет Promise.resolve(undefined)
}

fetchAndLog().then(() => {
  console.log('Fetch completed');
});

Пример 2: Функция с условиями

async function validateUser(id) {
  if (!id) {
    console.log('Invalid ID');
    // Неявный return undefined
  }
  // Если ID валиден, также нет return
  console.log('User valid');
}

validateUser(null).then(result => {
  console.log('Result:', result); // Result: undefined
});

Пример 3: Правильная обработка

async function processData() {
  const data = await fetch('/api/data').then(r => r.json());
  // Обработка данных...
}

processData()
  .then(() => {
    console.log('Processing complete');
  })
  .catch(error => {
    console.error('Error:', error);
  });

Важные моменты

1. Async функции ВСЕГДА возвращают Promise

Даже если функция не содержит await, она все равно вернет Promise:

async function simple() {
  console.log('Hello');
}

console.log(simple() instanceof Promise); // true

2. Ошибки в async функции отклоняют Promise

async function withError() {
  throw new Error('Something went wrong');
  // return здесь никогда не выполнится
}

withError().catch(error => {
  console.log(error.message); // Something went wrong
});

3. Нельзя просто ждать результата синхронно

async function getValue() {
  // Нет return
}

const result = getValue(); // Это Promise, не undefined!
console.log(result); // Promise { <pending> }

// Нужно использовать await
const value = await getValue(); // undefined

Сравнение с обычными функциями

// Обычная функция без return
function regular() {
  console.log('Hello');
}
const r1 = regular(); // undefined

// Async функция без return
async function asyncFunc() {
  console.log('Hello');
}
const r2 = asyncFunc(); // Promise { <pending> }

// Ключевое различие: async возвращает Promise!

Лучшие практики

1. Всегда возвращай значение, если оно нужно:

async function fetchUser(id) {
  const response = await fetch(`/api/users/${id}`);
  const user = await response.json();
  return user; // Явный return
}

1. Используй void type, если значение не нужно:

async function setup(): Promise<void> {
  // Инициализация
  console.log('Setup complete');
  // Явный return не нужен
}

1. Обрабатывай Promise корректно:

// Правильно
await asyncFunc();

// Неправильно - забыл await или .then()
asyncFunc(); // Promise будет в статусе pending

Вывод

Асинхронная функция без return ВСЕГДА возвращает Promise, разрешаемый со значением undefined. Это фундаментальное свойство async функций. Даже если функция не содержит никакого return, она все равно вернет Promise, в отличие от обычных функций, которые возвращают undefined напрямую.