我使用这个方法来展开混合数组：（这对我来说似乎最简单）。用较长的版本来解释步骤。

function flattenArray(deepArray) {
    // check if Array
    if(!Array.isArray(deepArray)) throw new Error('Given data is not an Array')

    const flatArray = deepArray.flat() // flatten array
    const filteredArray = flatArray.filter(item => !!item) // filter by Boolean
    const uniqueArray = new Set(filteredArray) // filter by unique values
    
    return [...uniqueArray] // convert Set into Array
}

//较短版本：

const flattenArray = (deepArray) => [...new Set(deepArray.flat().filter(item=>!!item))]

flattenArray([4,'a', 'b', [3, 2, undefined, 1], [1, 4, null, 5]])) // 4,'a','b',3,2,1,5

Codesandbox链接

现代方法

使用[].flat（Infinity）方法

const nestedArray = [1,[2,[3],[4,[5,[6,[7]]]]]]
const flatArray = nestedArray.flat(Infinity)
console.log(flatArray)

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

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.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））；

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

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

我最初想使用.reduce方法并递归调用一个函数来展平内部数组，但是当使用深度嵌套数组的深度嵌套数组时，这可能会导致堆栈溢出。使用concat也不是最好的方法，因为每次迭代都会创建数组的新浅层副本。我们可以做的是：

const flatten = arr => {
    for(let i = 0; i < arr.length;) {
        const val = arr[i];
        if(Array.isArray(val)) {
            arr.splice(i, 1, ...val);
        } else {
            i ++;
        }
    }
    return arr;
}

我们没有通过concat创建新数组，也没有递归调用任何函数。

http://jsbin.com/firiru/4/edit?js安慰

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