翻译服务

Promise对象表示一个异步操作的最终完成（或失败）及其结果值。

promise 的生命周期

一个Promise有三种状态：

1. pending
2. fulfilled
3. rejected

创建时，promise 处于 pending 状态。在未来的某个时刻，它可能会 resolve 或 reject。一旦 promise 被 resolve 或 reject 过一次，它就再也不能被 resolve 或 reject，其状态也无法改变。

换句话说：

1. 处于 pending 状态时，promise：
   • 可以转变为 fulfilled 或 rejected 状态。
2. 处于 fulfilled 状态时，promise：
   • 不得转变为任何其他状态。
   • 必须有一个值，且该值不得改变。
3. 处于 rejected 状态时，promise：
   • 不得转变为任何其他状态。
   • 必须有一个原因，且该原因不得改变。

promise 的 resolve

promise 可以通过多种方式被 resolve：

// Creates a promise that is immediately resolved
Promise.resolve(value);

// Creates a promise that is immediately resolved
new Promise((resolve) => {
  resolve(value);
});

// Chaining a promise leads to a resolved promise
somePromise.then(() => {
  // ...
  return value;
});

在上面的例子中，value可以是_任何东西_，包括错误、undefined、null或另一个 promise。通常你希望用一个不是错误的值来 resolve。

promise 的 reject

promise 可以通过多种方式被 reject：

// Creates a promise that is immediately rejected
Promise.reject(reason)

// Creates a promise that is immediately rejected
new Promise((_, reject) {
  reject(reason)
})

// Chaining a promise with an error leads to a rejected promise
somePromise.then(() => {
  // ...
  throw reason
})

在上面的例子中，reason可以是_任何东西_，包括错误、undefined或null。通常你希望用一个错误来 reject。

promise 的链式调用

promise 在 resolve 或 reject 之后，可以用一个后续操作来_继续_。

• 一旦promise resolve，就会调用promise.then()
• 一旦promise reject，就会调用promise.catch()
• 一旦promise resolve 或 reject，就会调用promise.finally()

then

每个 promise 都是“thenable”的。这意味着有一个可用的then函数，它会在原始 promise resolve 之后被执行。给定promise.then(onResolved)，回调onResolved会收到原始 promise 被 resolve 时所用的值。它总是会返回一个_新的_“链式”promise。

在then中返回一个value会让“链式”promise resolve。在then中抛出reason会让“链式”promise reject。

const promise1 = new Promise(function (resolve, reject) {
  setTimeout(() => {
    resolve('Success!');
  }, 1000);
});

const promise2 = promise1.then(function (value) {
  console.log(value);
  // expected output: "Success!"

  return true;
});

这会在大约 1000 毫秒后输出"Success!"。promise1的状态和值是resolved和"Success!"。promise2的状态和值是resolved和true。

还有一个可用的第二个实参，会在原始 promise reject 时执行。给定promise.then(onResolved, onRejected)，回调onResolved会收到原始 promise 被 resolve 时所用的值，或者回调onRejected会收到该 promise 被 reject 的原因。

const promise1 = new Promise(function (resolve, reject) {
  setTimeout(() => {
    resolve('Success!');
  }, 1000);

  if (Math.random() < 0.5) {
    reject('Nope!');
  }
});

function log(value) {
  console.log(value);
  return true;
}

function shout(reason) {
  console.error(reason.toUpperCase());
  return false;
}

const promise2 = promise1.then(log, shout);

• 在大约一半的情况下，这会在约 1000 毫秒后输出"Success!"。
  • promise1的状态和值会是resolved和"Success!"。
  • promise2的状态和值会是resolved和true。
• 在另外一半的情况下，这会立即输出"NOPE!"。
  • promise1的状态和值会是rejected和Nope!。
  • promise2的状态和值会是resolved和false。

有一点很重要：由于生命周期的规则，当它reject时，大约 1000 毫秒后才到来的resolve会被静默忽略，因为内部状态一旦 reject 或 resolve 就无法再改变。同样重要的是：从 promise 中返回一个值会让它 resolve，抛出一个值会让它 reject。当promise1 resolve，并且有链式的onResolved：then(onResolved)时，这段后续处理是一个新的 promise，可以 resolve 或 reject。当promise1 reject，但有链式的onRejected：then(, onRejected)时，这段后续处理是一个新的 promise，可以 resolve 或 reject。

catch

有时你想捕获错误，并且只在原始 promisereject时才继续。给定promise.catch(onCatch)，回调onCatch会收到原始 promise 被 reject 的原因。它总是会返回一个_新的_“链式”promise。

在catch中返回一个value会让“链式”promise resolve。在catch中抛出reason会让“链式”promise reject。

const promise1 = new Promise(function (resolve, reject) {
  setTimeout(() => {
    resolve('Success!');
  }, 1000);

  if (Math.random() < 0.5) {
    reject('Nope!');
  }
});

function log(value) {
  console.log(value);
  return 'done';
}

function recover(reason) {
  console.error(reason.toUpperCase());
  return 42;
}

const promise2 = promise1.catch(recover).then(log);

在大约一半的情况下，这会在约 1000 毫秒后输出"Success!"。在另外一半的情况下，这会立即输出42。

• 如果promise1 resolve，catch会被跳过，流程到达then，并输出该值。
  • promise1的状态和值会是resolved和"Success!"。
  • promise2的状态和值会是resolved和"done"；
• 如果promise1 reject，catch会执行，它_返回一个值_，因此链条现在处于resolved，流程到达then，并输出该值。
  • promise1的状态和值会是rejected和"Nope!"。
  • promise2的状态和值会是resolved和"done"；

finally

有时你希望在 promise settle 之后执行代码，无论这个 promise 是 resolve 还是 reject。给定promise.finally(onSettled)，回调onSettled不会收到任何东西。它总是会返回一个_新的_“链式”promise。

在finally中返回一个value会复制原始 promise 的状态和值，忽略该value。在finally中抛出reason会让“链式”promise reject，并覆盖原始 promise 的任何状态和值或原因。

示例

把各种方法组合在一起：

const myPromise = new Promise(function (resolve, reject) {
  const sampleData = [2, 4, 6, 8];
  const randomNumber = Math.round(Math.random() * 5);

  if (sampleData[randomNumber]) {
    resolve(sampleData[randomNumber]);
  } else {
    reject('Sampling did not result in a sample');
  }
});

const finalPromise = myPromise
  .then(function (sampled) {
    // If the random number was 0, 1, 2, or 3, this will be
    // reached and the number 2, 4, 6, or 8 will be logged.
    console.log(`Sampled data: ${sampled}`);
    return 'yay';
  })
  .catch(function (reason) {
    // If the random number was 4 or 5, this will be reached and
    // reason will be "An error occurred". The entire chain will
    // then reject with an Error with the reason as message.
    throw new Error(reason);
  })
  .finally(function () {
    // This will always log after either the sampled data is
    // logged or the error is raised.
    console.log('Promise completed');
  });

• 在randomNumber为0-3的情况下：
  • myPromise会 resolve，其值为2, 4, 6, or 8
  • finalPromise会 resolve，其值为'yay'
  • 会有两条日志：
    • Sampled data: ...
    • Promise completed
• 在randomNumber为4-5的情况下：
  • myPromise会 reject，其原因为'Sampling did not result in a sample'
  • finalPromise会 reject，其原因为Error('Sampling did not result in a sample')
  • 会有一条日志：
    • Promise completed
    • 在某些环境中，这会产生一条"uncaught rejected promise: Error('Sampling did not result in a sample')"日志

如上所示，reject可以使用字符串，而 promise 也可以用Error来 reject。