Promise.resolve()

基线广泛可用

此功能已得到良好建立，并且可在许多设备和浏览器版本上运行。它自以下时间起在浏览器中可用 2015 年 7 月.

Promise.resolve() 静态方法将给定值“解析”为 Promise。如果该值是 Promise，则返回该 Promise；如果该值是可 thenable 对象，则 Promise.resolve() 将调用 then() 方法，并使用它准备的两个回调；否则，返回的 Promise 将使用该值完成。

此函数将 Promise 类对象（例如，一个 Promise 完成到另一个 Promise 完成到某物）的嵌套层扁平化为单层——一个 Promise 完成到非可 thenable 值。

语法

Promise.resolve(value)

参数

value: 此 Promise 要解析的参数。也可以是 Promise 或要解析的可 thenable 对象。

返回值

使用给定值解析的 Promise，或者如果该值为 Promise 对象，则传递为值的 Promise。已解析的 Promise 可以处于任何状态——已完成、已拒绝或挂起。例如，解析已拒绝的 Promise 仍将导致已拒绝的 Promise。

描述

Promise.resolve() *解析* Promise，这与完成或拒绝 Promise 不同。有关术语的定义，请参阅 Promise 描述。简而言之，Promise.resolve() 返回一个 Promise，其最终状态取决于另一个 Promise、可 thenable 对象或其他值。

注意：如果评估 value 表达式可能会同步抛出错误，则 Promise.resolve() 不会捕获此错误并将其包装在已拒绝的 Promise 中。在这种情况下，请考虑使用 Promise.try(() => value)。

Promise.resolve() 是通用的，支持子类化，这意味着它可以在 Promise 的子类上调用，结果将是子类类型的 Promise。为此，子类的构造函数必须实现与 Promise() 构造函数相同的签名——接受单个 executor 函数，该函数可以用 resolve 和 reject 回调作为参数调用。

Promise.resolve() 对本机 Promise 实例进行了特殊处理。如果 value 属于 Promise 或其子类，并且 value.constructor === Promise，则 Promise.resolve() 将直接返回 value，而不会创建新的 Promise 实例。否则，Promise.resolve() 本质上是 new Promise((resolve) => resolve(value)) 的简写。

解析逻辑的大部分实际上是由 Promise() 构造函数传递的 resolve 函数实现的。总之

如果传递了非可 thenable 对象值，则返回的 Promise 已使用该值完成。
如果传递了可 thenable 对象，则返回的 Promise 将通过调用 then 方法并将一对解析函数作为参数传递来采用该可 thenable 对象的状态。（但由于本机 Promise 直接通过 Promise.resolve() 传递而无需创建包装器，因此不会在本机 Promise 上调用 then 方法。）如果 resolve 函数接收另一个可 thenable 对象，它将再次被解析，以便 Promise 的最终完成值永远不会是可 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

Promise.resolve() 重用现有的 Promise 实例。如果它正在解析本机 Promise，它将返回相同的 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 对象将被“深度扁平化”为单个 Promise。

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
});

警告：不要在解析自身的可 thenable 对象上调用 Promise.resolve()。这会导致无限递归，因为它试图扁平化无限嵌套的 Promise。

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

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

在非 Promise 构造函数上调用 resolve()

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),
    );
  }
}

Promise.resolve.call(NotPromise, "foo"); // Logs "Resolved foo"

扁平化嵌套可 thenable 对象的能力是由 Promise() 构造函数的 resolve 函数实现的，因此如果您在另一个构造函数上调用它，嵌套的可 thenable 对象可能不会被扁平化，具体取决于该构造函数如何实现其 resolve 函数。

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

Promise.resolve.call(NotPromise, thenable); // Logs "Resolved { then: [Function: then] }"

规范

规范
ECMAScript 语言规范 # sec-promise.resolve

浏览器兼容性

BCD 表格仅在启用 JavaScript 的浏览器中加载。

另请参阅

Promise