以下是Typescript中最快的解决方案，它也适用于具有多层嵌套的数组：

export function flatten<T>(input: Array<any>, output: Array<T> = []): Array<T> {
    for (const value of input) {
        Array.isArray(value) ? flatten(value, output) : output.push(value);
    }
    return output;
}

以及：

const result = flatten<MyModel>(await Promise.all(promises));

我最初想使用.reduce方法并递归调用一个函数来展平内部数组，但是当使用深度嵌套数组的深度嵌套数组时，这可能会导致堆栈溢出。使用concat也不是最好的方法，因为每次迭代都会创建数组的新浅层副本。我们可以做的是：

const flatten = arr => {
    for(let i = 0; i < arr.length;) {
        const val = arr[i];
        if(Array.isArray(val)) {
            arr.splice(i, 1, ...val);
        } else {
            i ++;
        }
    }
    return arr;
}

我们没有通过concat创建新数组，也没有递归调用任何函数。

http://jsbin.com/firiru/4/edit?js安慰

您可以使用“join（）”和“split（）”：

设arrs=[["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];让newArr=arrs.join（“，”）.split（“，“）；console.log（newArr）；//["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

此外，还可以使用“toString（）”和“split（）”：

设arrs=[["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];让newArr=arrs.toString（）.split（“，”）；console.log（newArr）；//["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

然而，如果字符串包含逗号，上述两种方式都不能正常工作：

“join（）”和“split（）”：

设arrs=[["$,6"],["$,12"],["$2,5"],["$2,5"],[",$18"],["$22,"],["$,1,0"]];让newArr=arrs.join（“，”）.split（“，“）；console.log（newArr）；// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]

“toString（）”和“split（）”：

设arrs=[["$,6"],["$,12"],["$2,5"],["$2,5"],[",$18"],["$22,"],["$,1,0"]];让newArr=arrs.toString（）.split（“，”）；console.log（newArr）；// ["$", "6", "$", "12", "$2", "5", "$2", "5", "", "$18", "$22", "", "$", "1", "0"]

我认为array.flat（Infinity）是一个完美的解决方案。但平面功能是一个相对较新的功能，可能不会在旧版本的浏览器中运行。我们可以使用递归函数来解决这个问题。

常量arr=[“A”，[“B”，[[“B11”，“B12”，[”B131“，“B132”]]，“B2”]]，”C“，[”D“，”E“，”F“，[“G”，“H”，“I”]]]常量flatArray=（arr）=>{常量res=[]for（arr的常量项）{if（Array.isArray（项））{const subRes=flatArray（项）资源推送（…subRes）}其他{res.push（项目）}}返回res}console.log（flatArray（arr））

更简单和直接的方法；可选择深压平；

const flatReduce = (arr, deep) => {
    return arr.reduce((acc, cur) => {
        return acc.concat(Array.isArray(cur) && deep ? flatReduce(cur, deep) : cur);
    }, []);
};

console.log(flatReduce([1, 2, [3], [4, [5]]], false)); // =>  1,2,3,4,[5]
console.log(flatReduce([1, 2, [3], [4, [5, [6, 7, 8]]]], true)); // => 1,2,3,4,5,6,7,8

另一个功能风格的ECMAScript 6解决方案：

声明函数：

const flatten = arr => arr.reduce(
  (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);

并使用它：

flatten( [1, [2,3], [4,[5,[6]]]] ) // -> [1,2,3,4,5,6]

常量flatten=arr=>arr.reduce(（a，b）=>a.oncat（Array.isArray（b）？压扁（b）：b），[]);console.log（展平（[1，[2,3]，[4]，[5]，[6]，[7,8,9]，10]，11]，[12]，13]）

还可以考虑在最新版本的现代浏览器中提供的本机函数Array.prototype.flat（）（针对ES6的建议）。感谢@（КонстантинВа）和@（Mark Amery）在评论中提到了这一点。

flat函数有一个参数，指定数组嵌套的预期深度，默认值为1。

[1, 2, [3, 4]].flat();                  // -> [1, 2, 3, 4]

[1, 2, [3, 4, [5, 6]]].flat();          // -> [1, 2, 3, 4, [5, 6]]

[1, 2, [3, 4, [5, 6]]].flat(2);         // -> [1, 2, 3, 4, 5, 6]

[1, 2, [3, 4, [5, 6]]].flat(Infinity);  // -> [1, 2, 3, 4, 5, 6]

设arr=[1，2，[3，4]]；console.log（arr.flat（））；arr=[1，2，[3，4，[5，6]]]；console.log（arr.flat（））；控制台日志（arr.flat（1））；控制台日志（arr.flat（2））；console.log（arr.flat（无限））；