async/await: синхронный вид асинхронного кода

Современный способ писать асинхронный код, читающийся как синхронный.

async/await — синтаксис поверх промисов. async-функция всегда возвращает промис, а await «приостанавливает» её до разрешения промиса, не блокируя поток.

То же, но читаемее

await разворачивает промис: вместо .then вы пишете присваивание. Код выглядит линейно.

function fetchValue() {
  return Promise.resolve(42);
}

async function main() {
  const value = await fetchValue(); // ждём результат
  console.log("значение:", value);
  return value + 1;
}

main().then((r) => console.log("вернулось:", r));

Вывод:

значение: 42
вернулось: 43

async-функция вернула 43, но обёрнутое в промис — поэтому снаружи мы достаём его через .then.

Ошибки через try/catch

Большой плюс await: ошибки ловятся обычным try/catch, как в синхронном коде.

async function run() {
  try {
    await Promise.reject(new Error("упало"));
  } catch (e) {
    console.log("поймали:", e.message);
  } finally {
    console.log("finally");
  }
}

run();
console.log("после вызова run()");

Вывод:

после вызова run()
поймали: упало
finally

Обратите внимание: «после вызова run()» печатается первым. await не блокирует основной поток — он откладывает остаток функции в микрозадачу.

Порядок выполнения с await

Код до первого await выполняется синхронно. Всё после await — уже микрозадача.

async function f() {
  console.log("1: до await");
  await null;
  console.log("3: после await");
}

console.log("0: старт");
f();
console.log("2: синхронный конец");

Вывод:

0: старт
1: до await
2: синхронный конец
3: после await

Параллельный запуск

Если задачи независимы, не ждите их по очереди — запустите сразу, а дождитесь через Promise.all. Иначе время сложится.

const task = (n) => Promise.resolve(n);

async function parallel() {
  const [a, b, c] = await Promise.all([task(1), task(2), task(3)]);
  console.log(a + b + c);
}

parallel();

Вывод:

Итог

async-функция всегда возвращает промис; await разворачивает его значение.
Ошибки ловятся обычным try/catch — большое удобство.
await не блокирует поток: код после него уходит в микрозадачу.