使用此方法展开两个阵列

arr1.concat(...arr2);

可以将Array.flat（）与Infinity一起用于任何深度的嵌套数组。

var arr=[[1,2,3,4]，[1,2，[1,2,3]]，[1,2,4,5，[1,3,4，[12,3,4，[12,3,4]]]，[[1,2,3-4]，[1,3，[1，2]，[1，2，3，5]，[1，3，4，[1，2,3,4]]]；let flatten=arr.flat（无限）console.log（展平）

在此处检查浏览器兼容性

当您的数组中可能有一些非数组元素时，这是一种更一般情况的解决方案。

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

我只是在寻找一个更快更简单的解决方案，为什么？因为我是一个面试问题，我很好奇，所以我做了这个：

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

var i = [[1,2,[3]],4,[2,3,4,[4,[5]]]], output;

// Start timing now
console.time("flatten");
output = new Array(JSON.stringify(i).replace(/[^\w\s,]/g,"")); 
output
// ... and stop.
console.timeEnd("flatten");

// Start timing now
console.time("flatten2");
output = [].concat.apply([], i)
output
// ... and stop.
console.timeEnd("flatten2");

// Start timing now
console.time("flatten3");
output = flattenArrayOfArrays(i)
output
// ... and stop.
console.timeEnd("flatten3");

我使用了这里最流行的答案和我的解决方案。我想有人会觉得这很有趣。干杯

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

根据请求，分解一行基本上就是这样。

function flatten(array) {
  // reduce traverses the array and we return the result
  return array.reduce(function(acc, b) {
     // if is an array we use recursion to perform the same operations over the array we found 
     // else we just concat the element to the accumulator
     return acc.concat( Array.isArray(b) ? flatten(b) : b);
  }, []); // we initialize the accumulator on an empty array to collect all the elements
}

这里的大多数答案都不适用于大型（例如200000个元素）阵列，即使这样，它们也很慢。

以下是最快的解决方案，它也适用于具有多层嵌套的阵列：

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

示例

巨大的阵列

flatten(Array(200000).fill([1]));

它可以很好地处理巨大的数组。在我的机器上，执行这段代码需要大约14毫秒。

嵌套数组

flatten(Array(2).fill(Array(2).fill(Array(2).fill([1]))));

它适用于嵌套数组。此代码生成[1，1，1，2，1，3，1，1]。

具有不同嵌套级别的数组

flatten([1, [1], [[1]]]);

它对像这样的扁平化阵列没有任何问题。