Промисы: основы

У промиса ровно три состояния. Сразу после создания он pending — ожидание, результата нет. Дальше он один раз переходит либо в fulfilled (успех, есть значение), либо в rejected (ошибка, есть причина). Момент перехода называют «улаживанием».

const ok = new Promise((resolve) => resolve(42));
const bad = new Promise((resolve, reject) => reject(new Error("сломалось")));

ok.then((value) => console.log("успех:", value));
bad.catch((error) => console.log("ошибка:", error.message));

Обратной дороги нет: из fulfilled в rejected промис не вернётся, и в ожидание — тоже. Одно состояние, один результат, навсегда.

Конструктор принимает одну функцию — её называют исполнителем. Движок сам передаёт в неё два аргумента: resolve для успеха и reject для ошибки. Внутри вы запускаете свою асинхронную работу и в нужный момент дёргаете одну из этих функций.

function loadUser(id) {
  return new Promise((resolve, reject) => {
    if (id > 0) resolve({ id: id, name: "Аня" });
    else reject(new Error("неверный id"));
  });
}
loadUser(7).then((user) => console.log(user.name));
loadUser(0).catch((error) => console.log(error.message));

В resolve передают любое значение, в reject — по договорённости объект Error: у него есть message и стек вызовов, с ним отладка в разы проще, чем со строкой.

Важная деталь: исполнитель запускается сразу и синхронно, прямо в момент new Promise. Асинхронным оказывается не он, а вызов обработчиков — они всегда откладываются на потом.

const p = new Promise((resolve) => {
  console.log("1: исполнитель работает сразу");
  resolve("значение");
});
p.then((value) => console.log("3:", value));
console.log("2: обычный код после создания");

then подписывается на успех, catch — на ошибку, finally — на любой исход. Каждый из них возвращает новый промис, поэтому их можно ставить цепочкой: то, что вернул обработчик, становится значением для следующего звена. Готовый улаженный промис создаётся коротко — Promise.resolve(значение).

Promise.resolve(10)
  .then((n) => n * 2)
  .then((n) => n + 1)
  .then((n) => console.log(n))
  .finally(() => console.log("цепочка завершена"));

Забыли return внутри then — следующий then получит undefined. Самая частая опечатка в цепочках.

Ошибка «проваливается» вниз по цепочке до первого catch: промежуточные then просто пропускаются. А finally не получает аргументов и ничего не меняет — он для уборки: спрятать спиннер, закрыть соединение.

const failed = new Promise((resolve, reject) => reject(new Error("нет сети")));

failed
  .then((value) => console.log("сюда не попадём", value))
  .catch((error) => console.log("поймали:", error.message))
  .finally(() => console.log("finally сработал"));

Promise.resolve("промис").then((value) => console.log(value));
console.log("обычный код");

У промиса нет методов cancel или abort. Подписка — это только чтение результата, а не управление работой. Если вы передумали и просто не подписались, работа всё равно доедет до конца: таймер сработает, запрос уйдёт на сервер, ответ придёт.

let needed = false; // передумали ждать
const request = new Promise((resolve) => {
  setTimeout(() => resolve("ответ сервера"), 100);
});
request.then((value) => {
  console.log(needed ? value : "результат пришёл, но он уже не нужен");
});

Отменять нужно источник, а не обёртку: для таймера — clearTimeout, для сетевого запроса — AbortController. Промис при этом обычно завершают через reject, чтобы вызывающий код понял: результата не будет.

const controller = new AbortController();
controller.signal.addEventListener("abort", () => {
  console.log("сигнал отмены получен");
});
controller.abort();
console.log(controller.signal.aborted);

Внутри исполнителя можно вызвать resolve и reject сколько угодно раз — сработает только первый. Остальные вызовы движок игнорирует молча: ни ошибки, ни предупреждения не будет. Это защита от гонок, а не повод писать лишние вызовы.

const p = new Promise((resolve, reject) => {
  resolve("первый");
  resolve("второй");
  reject(new Error("слишком поздно"));
});
p.then((value) => console.log(value));

Обратная сторона того же правила приятная: результат никуда не пропадает. Подписаться можно в любой момент — хоть через секунду после того, как промис улажен, — и обработчик всё равно получит сохранённое значение. Событие так не умеет: опоздал на него — потерял навсегда.

const done = Promise.resolve("готово");

done.then((value) => console.log("подписчик A:", value));
setTimeout(() => {
  done.then((value) => console.log("подписчик B:", value));
}, 50);