您还需要为每个数组项调用Promise.all：

const promise4all = Promise.all(
   promiseArray.map(function(innerPromiseArray) {
        return Promise.all(innerPromiseArray);
   })
);

或直接：

// Fix: Promise.all.bind is required because it seems like Promise.all
// implementation relies on "this"
const promise4All = Promise.all(promiseArray.map(Promise.all.bind(Promise)))
// or
// const promise4All = Promise.all(promiseArray.map(p => Promise.all(p)))

这样，外部的Promise.all得到其他Promise.all中的分组承诺：

promise4all.then(function(promiseGroupResult) {
  // promiseGroupResult is the actual result of each promise group
  // and you'll be able to get each result this way: promiseGroupResult.somePropertyName
});

你可以只在所有的内部数组上使用Promise.all，然后在外部数组上使用，来获得数组的数组的承诺：

Promise.all(promiseArrArr.map(Promise.all, Promise)).then(arrArr => …)

注意，Promise.all接受一个promise数组，而不是返回promise的函数数组。

另一个选择是将数组的数组扁平化为一个数组，然后直接在该数组上使用Promise.all()。直接从MDN上的一个示例开始，可以使用.reduce()和.concat()这样做：

var promises = [[promise1, promise2], [promise3,promise4], [promise5,promise6]];

Promise.all(promises.reduce(function(a, b) { return a.concat(b); }, []))
  .then(function(results) {
    // all done here
    // results are in a flattened array
});

这个解决方案允许原始promises数组包含单独的promises或promises数组或两者的任意组合。它在这方面很灵活，并且它在一个单一的结果平铺数组中提供结果，这些结果与原始promises的顺序相同，但被平铺到一个单一数组中。因为Promise.all()要求您向它传递一个数组，这里提出的其他解决方案要求输入是一个严格的数组--这个数组不能有任何明确的承诺，只有承诺的数组。2这个解决方案在这方面更灵活，可以接受任何一种类型的输入。
例如，如果输入恰好是这样的，那么这个方法就能很好地工作：

var promises = [promise1, promise2, [promise3, promise4], [promise5, promise6]];

参见工作演示：https://jsfiddle.net/jfriend00/dLsktyyn/
或者，您可能会发现将flatten()函数用于其他用途是很有用的：

function flatten(arr) {
    return arr.reduce(function(a, b) { return a.concat(b); }, []);
}

var promises = [[promise1, promise2], [promise3,promise4], [promise5,promise6]];

Promise.all(flatten(promises)).then(function(results) {
    // all done here
});

• • 编辑**

或者，Javascript数组现在有.flat()，它会为您将数组扁平化一层：

const promises = [[promise1, promise2], [promise3,promise4], [promise5,promise6]];

Promise.all(promises.flat()).then(function(results) {
    // all done here
    // results are in a flattened array
});

如果你有固定数量的子数组，我建议使用这个简单的解决方案：

const balancePromises = [...];
const symbolPromises = [...];

const [balances, symbols] = await Promise.all([
    Promise.all(balancePromises),
    Promise.all(symbolPromises)
]);

几个承诺也可以像这样并行：

const [
    balances,
    debt,
    name,
] = await Promise.all([
    this.contract.getBalanceOf(user),
    this.contract.getDebtOf(user),
    this.contract.getNameOf(user),
]);

如果你有嵌套的承诺数组-试试这个：

const nestedResults = await Promise.all(
    nestedPromises.map(promises => Promise.all(promises))
);

如果您希望将多阵列扁平化，并兑现所有承诺，现在可以执行以下操作：

const promiseAll = Promise.all(promiseArray.flat());

这是我的片段。

const a = Promise.resolve(1);
const b = Promise.resolve(2);
const c = Promise.resolve(3);
const d = Promise.resolve(4);

const e = Promise.all([a, b]);
const f = Promise.all([c, d]);

Promise.all([e, f])
    .then(res => console.log(res));

这就是结果。
[[1, 2], [3, 4]]

您可以使用以下方法：

var promisesArray = [
    [promise1, promise2],
    [promise3,promise4],
    [promise5,promise6]
].reduce(function (arr, item) {
    item.forEach(function (promise) {
       arr.push(promise);
    });
    return arr;
}, []);
Promise.all(promisesArray).then(function () {
    // code
});