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

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

请注意：当使用Function.prototype.apply（[].contat.apply（[]，arrays））或扩展运算符（[].cantat（…arrays），以展平数组时，这两者都会导致大型数组的堆栈溢出，因为函数的每个参数都存储在堆栈上。

这里是一个以功能风格实现的堆栈安全实现，它将最重要的需求相互权衡：

可重用性可读性简洁表演

//小型、可重复使用的辅助功能：常量foldl=f=>acc=>xs=>xs.reduce（uncurry（f），acc）；//aka减少常量未修正=f=>（a，b）=>f（a）（b）；常量concat=xs=>y=>xs.contat（y）；//使数组变平的实际函数-一个不言自明的单行：常量flatten=xs=>foldl（concat）（[]）（xs）；//任意数组大小（直到堆爆炸：D）常量xs=[[1,2,3]，[4,5,6]，[7,8,9]]；console.log（flatten（xs））；//推导深度嵌套数组的递归解决方案现在很简单//更小型、可重复使用的辅助功能：const-map=f=>xs=>xs.map（apply（f））；常量应用=f=>a=>f（a）；const-isArray=Array.isArray；//导出的递归函数：const flattenr=xs=>flatten（map（x=>isArray（x）？flatnr（x）：x）（xs））；常量ys=[1，[2，[3，[4，[5]，6，]，7]，8]，9]；控制台日志（flatnr（ys））；

一旦您习惯了小箭头函数的通用形式、函数组合和更高阶的函数，这段代码读起来就像散文一样。然后，编程只包括将总是按预期工作的小构件组合在一起，因为它们不包含任何副作用。

以下代码将压平深度嵌套的数组：

/**
 * [Function to flatten deeply nested array]
 * @param  {[type]} arr          [The array to be flattened]
 * @param  {[type]} flattenedArr [The flattened array]
 * @return {[type]}              [The flattened array]
 */
function flattenDeepArray(arr, flattenedArr) {
  let length = arr.length;

  for(let i = 0; i < length; i++) {
    if(Array.isArray(arr[i])) {
      flattenDeepArray(arr[i], flattenedArr);
    } else {
      flattenedArr.push(arr[i]);
    }
  }

  return flattenedArr;
}

let arr = [1, 2, [3, 4, 5], [6, 7]];

console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4, 5 ], [ 6, 7 ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7 ]

arr = [1, 2, [3, 4], [5, 6, [7, 8, [9, 10]]]];

console.log(arr, '=>', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4 ], [ 5, 6, [ 7, 8, [Object] ] ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

要在一行中展平二维阵列，请执行以下操作：

[[1, 2], [3, 4, 5]].reduce(Function.prototype.apply.bind(Array.prototype.concat))
// => [ 1, 2, 3, 4, 5 ]

现在，实现这一点的最佳且简单的方法是这样连接和拆分阵列。

var multipleArrays = [["$6","$Demo"], ["$12",["Multi","Deep"]], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]]

var flattened = multipleArrays.join().split(",")

此解决方案适用于多个级别，也是一个线性解决方案。

DEMO

ECMAScript 6的EDIT

由于ECMAScript 6已经标准化，您可以更改操作[].contat.apply（[]，arrays）；对于[].contat（…数组）；

var flattened = [].concat(...input);

DEMO

EDIT最高效的解决方案

解决这个问题最有效的方法是使用循环。您可以在此处比较“ops/sec”速度

var flattened=[];
for (var i=0; i<input.length; ++i) {
    var current = input[i];
    for (var j=0; j<current.length; ++j)
        flattened.push(current[j]);
} 

DEMO

希望有帮助

您可以继续使用Array.flat（）方法来实现这一点，即使数组嵌套得更多。

[1,2,3,[2]].flat() 

相当于

[1,2,3,[2]].flat(1)

所以当你的筑巢增加时，你可以继续增加数量。

eg:

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

如果您不确定嵌套的级别，可以只传递Infinity作为参数

[1,2,3,[2,[3,[3,[34],43],[34]]]].flat(Infinity) //[1, 2, 3, 2, 3, 3, 34, 43, 34]