re:re:actable
Урок 074 минуты чтения

Задача: свой Promise

На этой странице
Кратко

«Напишите свой Promise» — продвинутая задача, проверяющая понимание модели: три состояния (pending, fulfilled, rejected), однократная смена состояния, очередь колбэков, асинхронный вызов обработчиков (микрозадача через queueMicrotask), цепочки then (каждый then возвращает новый промис) и разворачивание промиса, возвращенного из обработчика. Полная спецификация Promises/A+ сложнее, но упрощенная версия на 60 строк — стандарт собеседования.

Вопрос

Реализуйте упрощенный класс MyPromise с конструктором (resolve, reject), методами then, catch, finally и статическими resolve и reject. Обработчики должны вызываться асинхронно, а then — поддерживать цепочки.

Решение

class MyPromise {
  #state = "pending";
  #value = undefined;
  #handlers = [];
 
  constructor(executor) {
    const resolve = (value) => this.#settle("fulfilled", value);
    const reject = (reason) => this.#settle("rejected", reason);
    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);                                 // ошибка в executor → rejected
    }
  }
 
  #settle(state, value) {
    if (this.#state !== "pending") return;           // состояние меняется один раз
 
    if (state === "fulfilled" && value && typeof value.then === "function") {
      value.then(                                    // разворачиваем промис/thenable
        (v) => this.#settle("fulfilled", v),
        (r) => this.#settle("rejected", r),
      );
      return;
    }
 
    this.#state = state;
    this.#value = value;
    this.#handlers.forEach((h) => this.#run(h));
    this.#handlers = [];
  }
 
  #run({ onFulfilled, onRejected, resolve, reject }) {
    queueMicrotask(() => {                           // обработчики всегда асинхронны
      const callback = this.#state === "fulfilled" ? onFulfilled : onRejected;
      if (typeof callback !== "function") {          // нет обработчика — пробрасываем дальше
        (this.#state === "fulfilled" ? resolve : reject)(this.#value);
        return;
      }
      try {
        resolve(callback(this.#value));              // результат обработчика → следующий промис
      } catch (error) {
        reject(error);
      }
    });
  }
 
  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      const handler = { onFulfilled, onRejected, resolve, reject };
      if (this.#state === "pending") this.#handlers.push(handler);
      else this.#run(handler);
    });
  }
 
  catch(onRejected) {
    return this.then(undefined, onRejected);
  }
 
  finally(onFinally) {
    return this.then(
      (value) => MyPromise.resolve(onFinally()).then(() => value),
      (reason) => MyPromise.resolve(onFinally()).then(() => { throw reason; }),
    );
  }
 
  static resolve(value) {
    return value instanceof MyPromise ? value : new MyPromise((resolve) => resolve(value));
  }
 
  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }
}

Проверка

console.log(1);
 
new MyPromise((resolve) => setTimeout(() => resolve(10), 100))
  .then((x) => x * 2)
  .then((x) => new MyPromise((resolve) => setTimeout(() => resolve(x + 1), 50))) // возврат промиса
  .then((x) => { throw new Error(`ошибка на ${x}`); })
  .catch((e) => e.message)
  .finally(() => console.log("finally"))
  .then(console.log);
 
MyPromise.resolve("sync").then(console.log);
console.log(2);
 
// 1
// 2
// sync          ← микрозадача, после синхронного кода
// finally       ← через ~150 мс
// ошибка на 21

Ключевые свойства

СвойствоГде в коде
состояние меняется один разпроверка pending в #settle
обработчики асинхронныqueueMicrotask в #run
then возвращает новый промисreturn new MyPromise(...)
возврат значения из then → следующий thenresolve(callback(value))
возврат промиса из then → ожиданиеразворачивание thenable в #settle
исключение в обработчике → rejectedtry/catch в #run
пропуск обработчика → проброс значенияветка typeof callback !== "function"
finally не меняет значение.then(() => value)

Доп. вопросы интервьюера

  • Почему queueMicrotask, а не setTimeout? нативные промисы используют очередь микрозадач — обработчики выполняются раньше таймеров.
  • Что упрощено по сравнению с Promises/A+? защита от циклов (resolve(this)), однократный вызов then у thenable, корректная работа с геттером then.
  • Как добавить MyPromise.all? так же, как в задаче про Promise.all.
  • Что такое unhandled rejection? отклоненный промис без обработчика; нативная реализация сообщает о нем событием.

Что важно помнить

  • Executor выполняется синхронно, обработчики — асинхронно.
  • then всегда создает новый промис — это и есть цепочка.
  • Ошибка в любом звене пропускает успешные обработчики до ближайшего catch.
  • Теория: Promise и его состояния, then, catch, finally, queueMicrotask.

Мини-шпаргалка

Состояние pending → fulfilled/rejected один раз. Очередь handlers пока pending. Обработчики через queueMicrotask. then → новый MyPromise, resolve(callback(value)), исключение → reject. Thenable разворачивается. catch = then(undefined, fn), finally сохраняет значение.

Документация

Promises/A+, MDN: Promise, MDN: queueMicrotask().

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам