使Promise.race仅在一次成功时结束

Promise.race是一个用于处理多个Promise对象的方法，它返回一个新的Promise对象，该对象将与第一个解决或拒绝的Promise对象具有相同的状态。

在使用Promise.race时，我们可以通过以下步骤使其仅在一次成功时结束：

创建一个空数组promises来存储所有的Promise对象。
创建一个新的Promise对象racePromise，作为Promise.race的返回值。
创建一个变量resolved，用于标记是否已经有Promise对象成功解决。
遍历传入的Promise对象数组，对于每个Promise对象，执行以下操作：
- 将Promise对象添加到promises数组中。
- 为每个Promise对象添加一个解决处理程序，该处理程序将执行以下操作：
  - 如果resolved为true，则忽略该Promise对象。
  - 否则，将resolved设置为true，并使用Promise.resolve将racePromise解决为该Promise对象的解决值。
- 为每个Promise对象添加一个拒绝处理程序，该处理程序将执行以下操作：
  - 如果resolved为true，则忽略该Promise对象。
  - 否则，将resolved设置为true，并使用Promise.reject将racePromise拒绝为该Promise对象的拒绝原因。

返回racePromise作为Promise.race的结果。

这样，当有一个Promise对象成功解决时，racePromise将立即解决为该Promise对象的解决值，并且不会再考虑其他Promise对象的状态。

以下是一个示例代码：

function racePromises(promises) {
  const racePromise = new Promise((resolve, reject) => {});
  const resolved = false;
  const resolvedHandler = (value) => {
    if (!resolved) {
      resolved = true;
      resolve(value);
    }
  };
  const rejectedHandler = (reason) => {
    if (!resolved) {
      resolved = true;
      reject(reason);
    }
  };

  const promisesArray = promises.map((promise) => {
    promise.then(resolvedHandler).catch(rejectedHandler);
    return promise;
  });

  return racePromise;
}

// 使用示例
const promise1 = new Promise((resolve) => setTimeout(resolve, 1000, 'Promise 1 resolved'));
const promise2 = new Promise((resolve) => setTimeout(resolve, 2000, 'Promise 2 resolved'));
const promise3 = new Promise((resolve) => setTimeout(resolve, 3000, 'Promise 3 resolved'));

const promises = [promise1, promise2, promise3];

const racePromise = racePromises(promises);

racePromise.then((value) => {
  console.log('Race promise resolved:', value);
}).catch((reason) => {
  console.log('Race promise rejected:', reason);
});

在上述示例中，我们创建了三个延迟不同的Promise对象，并使用racePromises函数对它们进行处理。由于promise1是第一个解决的Promise对象，racePromise将立即解决为'Promise 1 resolved'。