给定承诺列表，您如何实现"raceToSuccess"帮助程序？

我对ES6 Promise API中的某些内容感到困惑。我可以看到一个明确的用例，用于同时提交多个异步作业，并在第一次成功时"解决"。例如，这将适用于这样一种情况，即有多个等效的服务器可用，但有些可能已经停机，而另一些则负载严重且速度缓慢，所以我的目标是从第一个成功的服务器获得响应，而忽略其余的服务器（是的，我知道从服务器的角度来看，这对客户端来说是一种令人讨厌的行为方式，但对最终用户来说很好；）

然而，在我看来，我要么有"全部"行为，要么有"种族"行为。"all"行为似乎要等到所有请求都完成，这意味着我必须等待最慢的请求，即使服务器已经完成（事实上，我可能必须等待超时，在这种情况下这将是一场灾难。

API中是否存在允许"raceToSuccess"类型的行为，或者我是否必须手工构建它。就这一点而言，我将如何手工建造它？

顺便说一下，我在Java 8 CompletableFuture中发现了同样的难题，它似乎是一个非常相似的API。那么，我是不是在哲学层面上错过了什么？

这是一个经典的例子，反转逻辑可以使其更加清晰。在这种情况下，你的"种族"是你希望你的拒绝行为实际上是成功的行为。

function oneSuccess(promises){
  return Promise.all(promises.map(p => {
    // If a request fails, count that as a resolution so it will keep
    // waiting for other possible successes. If a request succeeds,
    // treat it as a rejection so Promise.all immediately bails out.
    return p.then(
      val => Promise.reject(val),
      err => Promise.resolve(err)
    );
  })).then(
    // If '.all' resolved, we've just got an array of errors.
    errors => Promise.reject(errors),
    // If '.all' rejected, we've got the result we wanted.
    val => Promise.resolve(val)
  );
}

您可以很容易地自己编写。

function raceToSuccess(promises) {
  return new Promise(
    resolve => 
      promises.forEach(
        promise => 
          promise.then(resolve)
      )
  );
}

这开启了所有的承诺，当任何一个成功时，都会用它的价值来解决新的承诺。失败的承诺将被忽略。由于新的承诺已经得到解决，随后成功的承诺不会发生任何事情。请注意，如果没有一个输入promise解析，则生成的promise将永远不会解析或拒绝。

这是一个修改后的版本，如果所有输入的承诺都被拒绝，它将返回一个被拒绝的承诺：

function raceToSuccess(promises) {
  let numRejected = 0;
  return new Promise(
    (resolve, reject) => 
      promises.forEach(
        promise => 
          promise . 
            then(resolve) .
            catch(
              () => {
                if (++numRejected === promises.length) reject(); 
              }
           )
       )
  );
}

我喜欢@loganofsmyth的方法；你可能应该为它的概念清晰性投赞成票。这里有一个变体：

function invertPromise(promise) {
  return new Promise(
    (resolve, reject) => 
      promise.then(reject, resolve)
  );
}
function raceToSuccess(promises) {
  return invertPromise(
    Promise.all(
      promises.map(invertPromise)));
}

另一个想法是将失败的承诺转化为既不解决也不拒绝的承诺（换句话说，是永久挂起的），然后使用Promise.race:

function pendingPromise()      { return new Promise(() => { }); }
function killRejected(promise) { return promise.catch(pendingPromise); }
function raceToSuccess(promises) {
  return Promise.race(promises.map(killRejected));
}

你可能喜欢也可能不喜欢这种行为。如果输入的promise都没有实现，则返回的promise将永远不会实现或拒绝。还有一种可能是，这些长期悬而未决的承诺不会得到GC的批准，或者一些引擎最终可能会抱怨它们。

我使用的是一个基于Promise.rece（）的函数，但有一个转折：它忽略拒绝，除非所有给定的Promise都拒绝：

// ignores any rejects except if all promises rejects
Promise.firstResolve = function (promises) {
    return new Promise(function (fulfil, reject) {
        var rejectCount = 0;
        promises.forEach(function (promise) {
            promise.then(fulfil, () => {
                rejectCount++;
                if(rejectCount == promises.length) {
                    reject('All promises were rejected');
                } 
            });
        });
    });
};

它基于Rich Harris的Promise polyfill竞赛方法。我只是让循环promise拒绝有条件：如果所有给定的promise都失败了，它只拒绝主promise，否则它忽略拒绝并解决第一个成功。

用法：

// fastest promise to end, but is a reject (gets ignored)
var promise1 = new Promise((resolve, reject) => {
    setTimeout(() => {
        reject("foo")
    }, 100);
})
// fastest promise to resolve (wins the race)
var promise2 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("bar")
    }, 200);
})
// Another, slower resolve (gets ignored)
var promise3 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("baz")
    }, 300);
})
Promise.firstResolve([promise1, promise2, promise3])
    .then((res) => {
        console.log(res) // "bar"
    })
    .catch(err => {
        console.log(err) // "All promises were rejected" (if all promises were to fail)
    })

我之所以使用这一方法而不是承诺反转方法，是因为在我看来这更具可读性。

为了以最严格的方式取悦这个问题，下面有一个版本可以解决第一个成功的承诺，但如果所有给定的承诺都失败了，则不会采取任何行动：

// ignores any and all rejects
Promise.firstResolve = function (promises) {
    return new Promise(function (fulfil) {
        promises.forEach(function (promise) {
            promise.then(fulfil, () => {});
        });
    });
};

（用法同上）

编辑：这实际上与@user663031的建议相同。直到现在我才意识到。

API中是否存在允许"；raceToSuccess"；行为类型

现在有了。Promise.any:的第4阶段提案已完成

Promise.any()接受Promise对象的一个可迭代对象，一旦可迭代对象中的一个Promise实现，就返回一个用该Promise的值解析的Promise。

因此，可以使用以下语法：

// assume getApi returns a Promise
const promises = [
  getApi('url1'),
  getApi('url2'),
  getApi('url3'),
  getApi('url4'),
];
Promise.any(promises)
  .then((result) => {
    // result will contain the resolve value of the first Promise to resolve
  })
  .catch((err) => {
    // Every Promise rejected
  });

Promise.any已经在所有现代浏览器中实现。也有一些聚乙烯填充物可用。

旧主题，但这是我的条目；它本质上是@loganofsmisth的解决方案，但需要进行更多的检查以符合Promise.all():建立的约定

作为输入的空数组（同步）返回已解析的promise
数组中的非promise条目导致第一个此类条目用作解析值

Promise.any = a => {
  return !a.length ?
    Promise.resolve() :
    Promise.all(a.map(
      e => (typeof e.then !== 'function') ?
        Promise.reject(e) :
        e.then(
          result => Promise.reject(result),
          failure => Promise.resolve(failure)
        )
    )).then(
      allRejected => Promise.reject(allRejected),
      firstResolved => Promise.resolve(firstResolved)
    );
};
// Testing...
function delayed(timeout, result, rejected) {
  return new Promise((resolve, reject) => {
    setTimeout(
      () => rejected ? reject(result) : resolve(result),
      timeout);
  });
}
Promise.any([
  delayed(800, 'a'),
  delayed(500, 'b'),
  delayed(250, 'c', true)
]).then(e => {
  console.log('First resolved (expecting b):', e);
});
Promise.any([
  delayed(800, 'a', true),
  delayed(500, 'b', true),
  delayed(250, 'c', true)
]).then(null, e => {
  console.log('All rejected (expecting array of failures):', e);
});
Promise.any([
  delayed(800, 'a'),
  delayed(500, 'b'),
  delayed(250, 'c', true),
  'd',
  'e'
]).then(e => {
  console.log('First non-promise (expecting d):', e);
});
// Because this is the only case to resolve synchronously,
// its output should appear before the others
Promise.any([]).then(e => {
  console.log('Empty input (expecting undefined):', e);
});

我用超时扩展了@loganofsmyth方法，并编写了一个小函数：

履行所有承诺
等待承诺成功的时间不超过指定的时间量（options.timeOutMs）
返回第一个成功的

在下面的片段中，您可以测试它：

const firstThatCompleteSuccessfullyES6 = (options) => {
    // return the first promise that resolve
    const oneSuccess = (promises) => Promise.all(promises.map(p => {
                    // If a request fails, count that as a resolution so it will keep
                    // waiting for other possible successes. If a request succeeds,
                    // treat it as a rejection so Promise.all immediately bails out.
                    return p.then(
                        (val) => { return Promise.reject(val); },
                        (err) => { return Promise.resolve(err); }
                    );
            })
            ).then(
                // If '.all' resolved, we've just got an array of errors.
                (errors) => { return Promise.reject(errors); },
                // If '.all' rejected, we've got the result we wanted.
                (val) => { return Promise.resolve(val); }
            );
    
    // return the promise or reect it if timeout occur first
    const timeoutPromise = (ms, promise) => new Promise(function(resolve, reject) {
            setTimeout(() => reject(new Error('timeout')), ms);
            promise.then(resolve, reject);
        });
    
    if (options.subsystems.length < 1) {
        return Promise.reject('Parameters error, no subSystems specified');
    }
    const timedOutSubsystems = options.subsystems.map(function(subsystem){
        return timeoutPromise(options.timeOutMs, subsystem(options));
    });
    const startDate = Date.now();
    return oneSuccess(
        timedOutSubsystems
    )
    .then((result) => {
        const elapsedTime = Math.abs((startDate - Date.now()) / 1000);
        console.log('firstThatCompleteSuccessfully() done, after s: ' + elapsedTime + ': '+ result);
        return result;
    })
    .catch((error) => {
        const elapsedTime = Math.abs((startDate - Date.now()) / 1000);
        console.error('firstThatCompleteSuccessfully() error/nodata: ' + error);
    });
}
// example of use with two promises (subsystem1 & subsystem2) that resolves after a fixed amount of time
const subsystem1 = (options) => new Promise(function(resolve, reject) {
        setTimeout(function(){
            console.log('subsystem1 finished');
            resolve('subsystem 1 OK');
        }, 1000);
    });
const subsystem2 = (options) => new Promise(function(resolve, reject) {
        setTimeout(function(){
            console.log('subsystem2 finished');
            resolve('subsystem 2 OK');
        }, 2000);
    });
firstThatCompleteSuccessfullyES6({
    subsystems: [subsystem1, subsystem2],
    timeOutMs: 2000
})
.then((result) => console.log("Finished: "+result));

为了解决这个问题，我使用了Promise.rice和Promise.allSettled。

下一个代码等待Promise.rice为成功值。但如果没有成功的结果。返回一个包含所有错误的数组。

const PromiseRiceSuccess = <T = unknown>(promises: Promise<T>[]) => {
  let done: (reason?: T) => void;
  const waitEndAllPromises = new Promise((resolve, reject) => done = reject);
  const waitCatchs = promise => Promise.resolve(promise).catch(() => waitEndAllPromises);
  Promise.allSettled(promises).then(r => done(r));
  return Promise.race(promises.map(waitCatchs));
};

示例：

PromiseRiceSuccess([
  Promise.reject(1),
  new Promise((r) => setTimeout(() => r(2), 4000)),
]);
// 2
PromiseRiceSuccess([
  Promise.reject(1),
  new Promise((resolve, reject) => setTimeout(() => reject(2), 4000)),
]);
// Uncaught (in promise) (2) [{…}, {…}]

相关内容

最新更新

热门标签：