另一个功能风格的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（无限））；

有一种比使用上面的答案中列出的merge.contat.apply（）方法快得多的方法来实现这一点，我的意思是速度快几个数量级。这假设您的环境可以访问ES5 Array方法。

var array2d = [
  ["foo", "bar"],
  ["baz", "biz"]
];
merged = array2d.reduce(function(prev, next) {
    return prev.concat(next);
});

这里是jsperf链接：http://jsperf.com/2-dimensional-array-merge

我只使用ES6回答这个问题，假设深度阵列是：

const deepArray = ['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];

如果您知道或猜测阵列的深度不超过7这样的数字，请使用以下代码：

const flatArray = deepArray.flat(7);

但如果你不知道深度数组的深度，或者你的JavaScript引擎不支持像react原生JavaScriptCore那样的flat，请使用下面的JavaScript reduce函数：

 const deepFlatten = arr =>
         arr.reduce(
           (acc, val) =>
             Array.isArray(val) 
               ? acc.concat(deepFlatten(val)) 
               : acc.concat(val),
             []
         );

这两种方法都返回以下结果：

["1", "a", "b", 2, "4", 3, "c", 5]

只是为了增加伟大的解决方案。我用递归来解决这个问题。

            const flattenArray = () => {
                let result = [];
                return function flatten(arr) {
                    for (let i = 0; i < arr.length; i++) {
                        if (!Array.isArray(arr[i])) {
                            result.push(arr[i]);
                        } else {
                            flatten(arr[i])
                        }
                    }
                    return result;
                }
            }

测试结果：https://codepen.io/ashermike/pen/mKZrWK

我认为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））

这是一个基于artif3x答案的Typescript版本，为Scala粉丝提供了flatMap的额外实现。

function flatten<T>(items: T[][]): T[] {
  return items.reduce((prev, next) => prev.concat(next), []);
}

function flatMap<T, U>(items: T[], f: (t: T) => U[]): U[] {
  return items.reduce((prev, next) => prev.concat(f(next)), new Array<U>());
}