JavaScript解析已按顺序填充的promise数组中的第一个元素

Question

我对不同的API（由delayedPromise函数模拟）执行多个请求，每个请求都需要一定的时间才能完成。如果其中一个满足，我返回它解析的值，就这样。我现在一个接一个地做这些，因为第一个请求是最准确的，而第二个则不太准确，等等。因此，如果第一个请求失败，第二个满足，我将返回第二个请求

为了加快速度，我考虑将这些请求并行化。为了实现这一点，我正在创建一个数组，它持有promise，它等待第一个元素的结果，如果失败，它等待第二个元素的结果等...

这是代码：

function promiseTest() {
    return new Promise(function (resolve, reject) {
        let promises = []
        new Promise(async function (resolve, reject) {
            promises.push(delayedPromise(true, 10000, "1")) //If true resolves after 10000 ms; false = reject
            promises.push(delayedPromise(false, 1000, "2"))
            promises.push(delayedPromise(false, 1000, "3"))
            let answer;
            let answer2
            let answer3;
            answer = await promises[0].catch(async err => {
                answer2 = await promises[1].catch(async err => {
                    answer3 = await promises[2].catch(err => { reject(err) })
                })
            })
            if (answer != undefined) {
                resolve(answer)
            }
            else if (answer2 != undefined) {
                resolve(answer2)
            }
            else if (answer3 != undefined) {
                resolve(answer3)
            }

        }).then(res => resolve(res)).catch(err => {reject(err)})

    })
}

function delayedPromise(bool, time,string ="") {
    return new Promise(function (resolve, reject) {
        if (bool) {
            setTimeout(resolve(string), time)
        }
        else {
            setTimeout(reject(), time)
        }
    })
}

问题是，虽然这种方法有效

答：很可能不是最好的解决方案，也很难扩展

B：上面的代码创建了一堆未捕获的异常错误。我相信这是当我收到答案1的结果时，我不会处理其他函数返回的任何拒绝。

有没有更好的方法来解决上述问题？如果有任何想法或改进，我将不胜感激！非常感谢

附言：如果你能更好地表达我的标题，请让我知道我正在努力用一句话来表达我的问题

Answer 1

我认为，在仍然并行运行promise的同时（为了获得最佳的端到端时间），对结果进行加权以支持promise需要构建一个特殊的循环。我想你可以这样做：

const errResult = Symbol('errResult');

// fns is an array of functions to call
// args is a array of arguments to pass to each function (same args to each)
async function getResult(fns, args) {
    // start all the async operations to run in parallel
    const promises = fns.map(fn => {
        // Rejections will resolve with a sentinel value so we can detect them
        // This helps us avoid ever getting an unhandled rejection error
        // on promises that reject after we've already found our desired value
        return fn(...args).catch(err => {
            return errResult;
        });
    });
    // now await them in order so you can find the first
    // one that completes (in order)
    // Promises that rejected have been converted into an errResult
    // resolve to help in avoiding unhandled rejections
    // after we return with our good first result
    for (let p of promises) {
        let result = await p;
        if (result !== errResult) {
            return result;
        }
    }
    throw new Error('no results');
}


// sample usage:
getResult([fn1, fn2, fn3, fn4], [argA,argB]).then(result => {
    console.log(result);
}).catch(err => {
    console.log("no results found");
});

如果您希望每个函数都有不同的参数，那么只需将其构建到fn1、fn2等中...这样他们就可以用所需的参数调用根函数，然后让args数组成为一个空数组。

Answer 2

问题中的代码简化为：

function promiseTest() {
    let promises = [
        delayedPromise(true, 10000, '1'),
        delayedPromise(false, 1000, '2'),
        delayedPromise(false, 1000, '3')
    ];
    return promises[0]
    .catch(() => promises[1])
    .catch(() => promises[2]);
}

一旦遇到成功的promise，链将停止捕获，成功的结果将一路下降，以传递（proverd-wrp）给promise测试的调用方。

捕获链也可以写如下。。。

Promise.reject()
.catch(() => promises[0])
.catch(() => promises[1])
.catch(() => promises[2]);

... 这有助于为任意长度的数组制定过程化版本，如下所示：

function promiseTest() {
    let promises = [...]; // array of Promises (any length)
    return promises.reduce((p_, p) => p_.catch(() => p), Promise.reject());
}

假设在制定promise数组时没有采取措施避免未经处理的拒绝，您可以在减少中这样做（使用一系列“分支捕获”）。。。

function promiseTest() {
    let promises = [...]; // array of Promises (any length).
    return promises.reduce((p_, p) => {
        p.catch(() => null); // avoid unhandled rejections.
        return p_.catch(() => p);
    }, Promise.reject());
}

Answer 3

Promise.any和Promise.all解决非常相似，但并不完全符合您的要求。你必须自己建造它。这就是我要做的：

async function first(iterable) {
    const promises = [];
    for (const thenable of iterable) {
        const promise = Promise.resolve(thenable);
        promises.push(promise);
        promise.catch(() => {}); // ignore rejections, we'll handle them later
    }
    const errors = [];
    for (const promise of promises) {
        try {
            return await promise;
        } catch(error) {
            errors.push(error);
        }
    }
    throw new AggregateError(errors);
}