事件：'multipleResolves'

¥Event: 'multipleResolves'

• type <string> 解决类型'resolve' 或 'reject' 之一。

  ¥type <string> The resolution type. One of 'resolve' or 'reject'.

• promise <Promise> 不止一次解决或拒绝的 promise。

  ¥promise <Promise> The promise that resolved or rejected more than once.

• value <any> 在原始解决之后解决或拒绝 promise 的值。

  ¥value <any> The value with which the promise was either resolved or rejected after the original resolve.

每当 Promise 满足以下任一条件时，就会触发 'multipleResolves' 事件：

¥The 'multipleResolves' event is emitted whenever a Promise has been either:

• 解决了不止一次。

  ¥Resolved more than once.

• 拒绝了不止一次。

  ¥Rejected more than once.

• 解决后拒绝。

  ¥Rejected after resolve.

• 拒绝后解决。

  ¥Resolved after reject.

这对于在使用 Promise 构造函数时跟踪应用中的潜在错误很有用，因为多个解决被静默吞下。但是，此事件的发生并不一定表示错误。例如，Promise.race() 可以触发 'multipleResolves' 事件。

¥This is useful for tracking potential errors in an application while using the Promise constructor, as multiple resolutions are silently swallowed. However, the occurrence of this event does not necessarily indicate an error. For example, Promise.race() can trigger a 'multipleResolves' event.

由于在上面的 Promise.race() 示例这样的情况下事件的不可靠性，它已被弃用。

¥Because of the unreliability of the event in cases like the Promise.race() example above it has been deprecated.

import process from 'node:process';

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First callconst process = require('node:process');

process.on('multipleResolves', (type, promise, reason) => {
  console.error(type, promise, reason);
  setImmediate(() => process.exit(1));
});

async function main() {
  try {
    return await new Promise((resolve, reject) => {
      resolve('First call');
      resolve('Swallowed resolve');
      reject(new Error('Swallowed reject'));
    });
  } catch {
    throw new Error('Failed');
  }
}

main().then(console.log);
// resolve: Promise { 'First call' } 'Swallowed resolve'
// reject: Promise { 'First call' } Error: Swallowed reject
//     at Promise (*)
//     at new Promise (<anonymous>)
//     at main (*)
// First call拷贝