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

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

如何使用JavaScript 1.8的reduce（callback[，initialValue]）方法

list.reduce((p,n) => p.concat(n),[]);

能胜任这项工作。

您也可以尝试新的Array.flat（）方法。其工作方式如下：

let arr=[[“$6”]，[“$12”]，【“$25”】，[“$25“]，【”$18“】，【”$22“】，[”$10“]].flat（）控制台日志（arr）；

flat（）方法创建一个新数组，所有子数组元素递归地连接到其中，直到1层深度（即数组内部的数组）

如果您还想展平三维或更高维度的数组，只需多次调用flat方法。例如（三维）：

设arr=[1,2，[3,4，[5,6]]].flat（）.flat；控制台日志（arr）；

小心！

Array.flat（）方法相对较新。像ie这样的旧浏览器可能没有实现该方法。如果你想让你的代码在所有浏览器上运行，你可能需要将你的JS转换成一个旧版本。检查MDN web文档的当前浏览器兼容性。

const common = arr.reduce((a, b) => [...a, ...b], [])

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

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

我写的简单的flatten util

const flatten = (arr, result = []) => {
    if (!Array.isArray(arr)){
        return [...result, arr];
    }
     arr.forEach((a) => {
         result = flatten(a, result)
    })

    return result
}

console.log(flatten([1,[2,3], [4,[5,6,[7,8]]]])) // [ 1, 2, 3, 4, 5, 6, 7, 8 ]