我最近建立了一个库，可以满足你的需要。它并行执行承诺，如果一个承诺失败，进程继续，最后它返回一个包含所有结果的数组，包括错误。

https://www.npmjs.com/package/promise-ax

我希望这对某些人有帮助。

const { createPromise } = require('promise-ax');
const promiseAx = createPromise();
const promise1 = Promise.resolve(4);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, new Error("error")));
const promise3 = Promise.reject("error");
const promise4 = promiseAx.resolve(8);
const promise5 = promiseAx.reject("errorAx");
const asyncOperation = (time) => {
    return new Promise((resolve, reject) => {
        if (time < 0) {
            reject("reject");
        }
        setTimeout(() => {
            resolve(time);
        }, time);
    });
};
const promisesToMake = [promise1, promise2, promise3, promise4, promise5, asyncOperation(100)];
promiseAx.allSettled(promisesToMake).then((results) =>   results.forEach((result) => console.log(result)));
// Salida esperada:
// 4
// Error: error
// error
// 8
// errorAx
// 100

更新，你可能需要使用内置的本机promise . allsettle:

Promise.allSettled([promise]).then(([result]) => {
   //reach here regardless
   // {status: "fulfilled", value: 33}
});

作为一个有趣的事实，下面的答案是将该方法添加到语言中的现有技术:]

当然，你只需要反思一下:

const reflect = p => p.then(v => ({v, status: "fulfilled" }),
                            e => ({e, status: "rejected" }));

reflect(promise).then((v) => {
    console.log(v.status);
});

或者使用ES5:

function reflect(promise){
    return promise.then(function(v){ return {v:v, status: "fulfilled" }},
                        function(e){ return {e:e, status: "rejected" }});
}


reflect(promise).then(function(v){
    console.log(v.status);
});

或者在你的例子中:

var arr = [ fetch('index.html'), fetch('http://does-not-exist') ]

Promise.all(arr.map(reflect)).then(function(results){
    var success = results.filter(x => x.status === "fulfilled");
});

我不知道你在使用哪个承诺库，但大多数都有类似allsettle的东西。

编辑:好的，因为你想使用普通的ES6而没有外部库，没有这样的方法。

换句话说:您必须手动遍历承诺，并在所有承诺解决后立即解决新的组合承诺。

的承诺。所有这些都使用现代异步/等待方法

const promise1 = //...
const promise2 = //...

const data = await Promise.all([promise1, promise2])

const dataFromPromise1 = data[0]
const dataFromPromise2 = data[1]

Benjamin Gruenbaum的回答当然很好。但我也能看出内森哈根的观点在抽象层面上显得模糊。拥有像e和v这样的短对象属性也没有帮助，但当然这是可以改变的。

在Javascript中有一个标准的Error对象，称为Error。理想情况下，您总是抛出该实例/后代。这样做的好处是您可以使用instanceof Error，并且您知道某些东西是错误的。

利用这个想法，下面是我对这个问题的看法。

基本上捕捉错误，如果错误不是error类型，则将错误包装在error对象中。结果数组将具有已解析的值或可以检查的Error对象。

catch内部的instanceof，是为了防止你使用一些外部库可能会reject("error")，而不是reject(new error ("error"))。

当然，如果您解决了一个错误，您也可以有承诺，但在这种情况下，无论如何都应该将其视为错误，就像最后一个示例所示的那样。

这样做的另一个好处是，数组析构保持简单。

const [value1, value2] = PromiseAllCatch(promises);
if (!(value1 instanceof Error)) console.log(value1);

而不是

const [{v: value1, e: error1}, {v: value2, e: error2}] = Promise.all(reflect..
if (!error1) { console.log(value1); }

你可能会说!error1检查比instanceof简单，但你也必须销毁v和e。

function PromiseAllCatch(promises) { return Promise.all(promises.map(async m => { try { return await m; } catch(e) { if (e instanceof Error) return e; return new Error(e); } })); } async function test() { const ret = await PromiseAllCatch([ (async () => "this is fine")(), (async () => {throw new Error("oops")})(), (async () => "this is ok")(), (async () => {throw "Still an error";})(), (async () => new Error("resolved Error"))(), ]); console.log(ret); console.log(ret.map(r => r instanceof Error ? "error" : "ok" ).join(" : ")); } test();

我认为下面提供了一个稍微不同的方法……比较fn_fast_fail()和fn_slow_fail()…尽管后者并没有因此而失败……你可以检查a和b中是否有一个或两个都是Error实例，如果你想让它到达catch块，就抛出这个错误(例如if (b instanceof Error) {throw b;})。参见jsfiddle。

var p1 = new Promise((resolve, reject) => { 
    setTimeout(() => resolve('p1_delayed_resolvement'), 2000); 
}); 

var p2 = new Promise((resolve, reject) => {
    reject(new Error('p2_immediate_rejection'));
});

var fn_fast_fail = async function () {
    try {
        var [a, b] = await Promise.all([p1, p2]);
        console.log(a); // "p1_delayed_resolvement"
        console.log(b); // "Error: p2_immediate_rejection"
    } catch (err) {
        console.log('ERROR:', err);
    }
}

var fn_slow_fail = async function () {
    try {
        var [a, b] = await Promise.all([
            p1.catch(error => { return error }),
            p2.catch(error => { return error })
        ]);
        console.log(a); // "p1_delayed_resolvement"
        console.log(b); // "Error: p2_immediate_rejection"
    } catch (err) {
        // we don't reach here unless you throw the error from the `try` block
        console.log('ERROR:', err);
    }
}

fn_fast_fail(); // fails immediately
fn_slow_fail(); // waits for delayed promise to resolve