有一种比使用上面的答案中列出的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

ES2019年

ES2019引入了Array.protocol.flat（）方法，您可以使用它来展平阵列。它与大多数环境兼容，尽管它仅在Node.js版本11开始提供，而在Internet Explorer中根本不提供。

常量数组=[["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];const merge3=arrays.flat（1）//指定嵌套数组结构应展平的深度级别。默认值为1。console.log（合并3）；

较旧的浏览器

对于较旧的浏览器，可以使用Array.prototype.cocat合并数组：

var数组=[["$6"],["$12"],["$25"],["$25"],["$18"],["$22"],["$10"]];var merged=[].contat.apply（[]，数组）；console.log（合并）；

使用concat的apply方法将只将第二个参数作为数组，因此最后一行与此相同：

var merged = [].concat(["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]);

可以将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（展平）

在此处检查浏览器兼容性

这是我的版本。它允许您将复杂的对象展平，可以在更多场景中使用：

输入

var input = {
   a: 'asdf',
   b: [1,2,3],
   c: [[1,2],[3,4]],
   d: {subA: [1,2]}
}

Code

功能如下：

function flatten (input, output) {

  if (isArray(input)) {
    for(var index = 0, length = input.length; index < length; index++){
      flatten(input[index], output);
    }
  }
  else if (isObject(input)) {
    for(var item in input){
      if(input.hasOwnProperty(item)){
        flatten(input[item], output);
      }
    }
  }
  else {
    return output.push(input);
  }
};

function isArray(obj) {
  return Array.isArray(obj) || obj.toString() === '[object Array]';
}

function isObject(obj) {
  return obj === Object(obj);
}

用法

var output = []

flatten(input, output);

输出

[“asdf”，1,2,3,1,2,3,4,1,2]

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

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

前几天我和ES6发电机玩得很开心，写了这篇文章。其中包含。。。

function flatten(arrayOfArrays=[]){
  function* flatgen() {
    for( let item of arrayOfArrays ) {
      if ( Array.isArray( item )) {
        yield* flatten(item)
      } else {
        yield item
      }
    }
  }

  return [...flatgen()];
}

var flatArray = flatten([[1, [4]],[2],[3]]);
console.log(flatArray);

基本上，我正在创建一个生成器，它在原始输入数组上循环，如果它找到一个数组，它将使用yield*运算符与递归相结合，以不断展平内部数组。如果项不是数组，则只生成单个项。然后使用ES6 Spread运算符（也称为splat运算符），我将生成器展平为一个新的数组实例。

我还没有测试它的性能，但我认为这是一个使用生成器和yield*运算符的简单示例。

但是，我又一次只是在偷懒，所以我相信有更多的表演方式可以做到这一点。