Promise.resolve()

Статический метод Promise.resolve() «разрешает» (resolves) заданное значение в Promise. Если значение является промисом, возвращается этот промис; если значение является thenable-объектом, Promise.resolve() вызовет метод then() с двумя подготовленными им колбэками; в противном случае возвращённый промис будет исполнен этим значением.

Эта функция сглаживает вложенные слои промисоподобных объектов (например, промис, который исполняется промисом, который исполняется чем-то) в один слой — промис, который исполняется не-thenable-значением.

Попробовать

const promise1 = Promise.resolve(123);

promise1.then((value) => {
  console.log(value);
  // Expected output: 123
});

Синтаксис

Promise.resolve(value)

Параметры

value

Аргумент, который должен быть разрешён этим Promise. Также может быть Promise или thenable-объектом для разрешения.

Возвращаемое значение

Объект Promise, который разрешён заданным значением, или промис, переданный как значение, если это значение было объектом-промисом. Разрешённый промис может находиться в любом из состояний — исполненном (fulfilled), отклонённом (rejected) или ожидающем (pending). Например, разрешение отклонённого промиса всё равно приведёт к отклонённому промису.

Описание

Promise.resolve() разрешает (resolves) промис, что не то же самое, что исполнение (fulfilling) или отклонение (rejecting) промиса. Определения терминологии см. в описании Promise. Короче говоря, Promise.resolve() возвращает промис, конечное состояние которого зависит от другого промиса, thenable-объекта или другого значения.

Promise.resolve() является общим (generic) и поддерживает наследование (subclassing), что означает, что он может быть вызван для подклассов Promise, и результатом будет промис типа подкласса. Для этого конструктор подкласса должен реализовать ту же сигнатуру, что и конструктор Promise() — принимая одну функцию executor, которую можно вызвать с колбэками resolve и reject в качестве параметров.

Promise.resolve() обрабатывает нативные экземпляры Promise особым образом. Если value принадлежит Promise или подклассу, и value.constructor === Promise, то value возвращается напрямую методом Promise.resolve() без создания нового экземпляра Promise. В противном случае, Promise.resolve() по существу является сокращением для new Promise((resolve) => resolve(value)).

Основная часть логики разрешения фактически реализована функцией resolve, переданной конструктором Promise(). В итоге:

• Если передаётся не-thenable значение, возвращаемый промис уже исполнен этим значением.
• Если передаётся thenable-объект, возвращаемый промис примет состояние этого thenable-объекта путём вызова метода then и передачи пары функций разрешения в качестве аргументов. (Но поскольку нативные промисы напрямую проходят через Promise.resolve() без создания обёртки, метод then не вызывается для нативных промисов.) Если функция resolve получает другой thenable-объект, он будет разрешён снова, так что конечное исполненное значение промиса никогда не будет thenable-объектом.

Примеры

Использование статического метода Promise.resolve

Promise.resolve("Success").then(
  (value) => {
    console.log(value); // "Success"
  },
  (reason) => {
    // not called
  },
);

Разрешение массива

const p = Promise.resolve([1, 2, 3]);
p.then((v) => {
  console.log(v[0]); // 1
});

Разрешение другого промиса

Promise.resolve() повторно использует существующие экземпляры Promise. Если он разрешает нативный промис, он возвращает тот же экземпляр промиса без создания обёртки.

const original = Promise.resolve(33);
const cast = Promise.resolve(original);
cast.then((value) => {
  console.log(`value: ${value}`);
});
console.log(`original === cast ? ${original === cast}`);

// Logs, in order:
// original === cast ? true
// value: 33

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

Разрешение thenable-объектов и генерация ошибок

// Resolving a thenable object
const p1 = Promise.resolve({
  then(onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true, object casted to a Promise

p1.then(
  (v) => {
    console.log(v); // "fulfilled!"
  },
  (e) => {
    // not called
  },
);

// Thenable throws
// Promise rejects
const p2 = Promise.resolve({
  then() {
    throw new TypeError("Throwing");
  },
});
p2.then(
  (v) => {
    // not called
  },
  (e) => {
    console.error(e); // TypeError: Throwing
  },
);

// Thenable throws after callback
// Promise resolves
const p3 = Promise.resolve({
  then(onFulfilled) {
    onFulfilled("Resolving");
    throw new TypeError("Throwing");
  },
});
p3.then(
  (v) => {
    console.log(v); // "Resolving"
  },
  (e) => {
    // not called
  },
);

Вложенные thenable-объекты будут «глубоко сглажены» до одного промиса.

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled({
      // The thenable is fulfilled with another thenable
      then(onFulfilled, onRejected) {
        onFulfilled(42);
      },
    });
  },
};

Promise.resolve(thenable).then((v) => {
  console.log(v); // 42
});

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled(thenable);
  },
};

Promise.resolve(thenable); // Will lead to infinite recursion.

Вызов resolve() для конструктора, не являющегося Promise

Promise.resolve() — это общий метод. Его можно вызвать для любого конструктора, который реализует ту же сигнатуру, что и конструктор Promise(). Например, мы можем вызвать его для конструктора, который передаёт console.log как resolve:

class NotPromise {
  constructor(executor) {
    // The "resolve" and "reject" functions behave nothing like the
    // native promise's, but Promise.resolve() calls them in the same way.
    executor(
      (value) => console.log("Resolved", value),
      (reason) => console.log("Rejected", reason),
    );
  }

  static resolve = Promise.resolve;
}

const p = NotPromise.resolve("foo"); // Logs "Resolved foo"
// p is a NotPromise instance

Возможность сглаживать вложенные thenable-объекты реализована функцией resolve конструктора Promise(), поэтому, если вы вызываете её для другого конструктора, вложенные thenable-объекты могут не быть сглажены, в зависимости от того, как этот конструктор реализует свою функцию resolve.

const thenable = {
  then(onFulfilled, onRejected) {
    onFulfilled({
      // The thenable is fulfilled with another thenable
      then(onFulfilled, onRejected) {
        onFulfilled(42);
      },
    });
  },
};

const p = NotPromise.resolve(thenable); // Logs "Resolved { then: [Function: then] }"
// p is a NotPromise instance

Спецификации

Совместимость с браузерами

См. также

• Promise