Promise.resolve()
resolves a promise, which is not the same as fulfilling or rejecting the promise. See Promise description for definitions of the terminology. In brief, Promise.resolve()
returns a promise whose eventual state depends on another promise, thenable object, or other value.
Promise.resolve()
is generic and supports subclassing, which means it can be called on subclasses of Promise
, and the result will be a promise of the subclass type. To do so, the subclass's constructor must implement the same signature as the Promise()
constructor — accepting a single executor
function that can be called with the resolve
and reject
callbacks as parameters.
Promise.resolve()
special-cases native Promise
instances. If value
belongs to Promise
or a subclass, and value.constructor === Promise
, then value
is directly returned by Promise.resolve()
, without creating a new Promise
instance. Otherwise, Promise.resolve()
is essentially a shorthand for new Promise((resolve) => resolve(value))
.
The bulk of the resolving logic is actually implemented by the resolve
function passed by the Promise()
constructor. In summary:
- If a non-thenable value is passed, the returned promise is already fulfilled with that value.
- If a thenable is passed, the returned promise will adopt the state of that thenable by calling the
then
method and passing a pair of resolving functions as arguments. (But because native promises directly pass through Promise.resolve()
without creating a wrapper, the then
method is not called on native promises.) If the resolve
function receives another thenable object, it will be resolved again, so that the eventual fulfillment value of the promise will never be thenable.