更新：事实证明，这种解决方案不适用于大型阵列。如果您正在寻找更好、更快的解决方案，请查看此答案。

function flatten(arr) {
  return [].concat(...arr)
}

Is简单地展开arr并将其作为参数传递给concat（），concat将所有数组合并为一个数组。它相当于[].contat.apply（[]，arr）。

您也可以尝试此方法进行深压平：

function deepFlatten(arr) {
  return flatten(           // return shalowly flattened array
    arr.map(x=>             // with each x in array
      Array.isArray(x)      // is x an array?
        ? deepFlatten(x)    // if yes, return deeply flattened x
        : x                 // if no, return just x
    )
  )
}

请参阅JSBin上的演示。

本回答中使用的ECMAScript 6元素的引用：

Spread运算符箭头功能

附带说明：并非所有浏览器都支持find（）和arrow函数等方法，但这并不意味着您现在不能使用这些功能。只需使用Babel-它将ES6代码转换为ES5。

只有没有lodash的最佳解决方案

let flatten = arr => [].concat.apply([], arr.map(item => Array.isArray(item) ? flatten(item) : item))

递归调用deepFlatten函数，这样我们就可以在不使用任何外部助手方法的情况下扩展内部数组。

const innerArr = ['a', 'b'];
const multiDimArr = [[1, 2], 3, 4, [5, 6, innerArr], 9];

const deepFlatten = (arr) => {
  const flatList = [];
  arr.forEach(item => {
    Array.isArray(item)
     ? flatList.push(...deepFlatten(item)) // recursive call
     : flatList.push(item)
  });
  return flatList;
}

这里的大多数答案都不适用于大型（例如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]]]);

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

如果您需要支持IE8，因此无法使用reduce或isArray等方法，这里有一个可能的解决方案。这是一种冗长的方法，可以帮助您理解递归算法。

function flattenArray(a){

    var aFinal = [];

    (function recursiveArray(a){

        var i,
            iCount = a.length;

        if (Object.prototype.toString.call(a) === '[object Array]') {
            for (i = 0; i < iCount; i += 1){
                recursiveArray(a[i]);
            }
        } else {
            aFinal.push(a);
        }

    })(a);

    return aFinal;

}

var aMyArray = [6,3,4,[12,14,15,[23,24,25,[34,35],27,28],56],3,4];

var result = flattenArray(aMyArray);

console.log(result);

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"]);