ES6的纯粹魔力

const flat = A => A.reduce((A, a) => Array.isArray(a) ? [...A, ...flat(a)] : [...A, a], []);

要展平单个元素数组的数组，不需要导入库，简单的循环是最简单和最有效的解决方案：

for (var i = 0; i < a.length; i++) {
  a[i] = a[i][0];
}

对反对选民：请阅读问题，不要因为它不适合你的不同问题而反对投票。对于所问的问题，此解决方案是最快和最简单的。

ES6方式：

constflatten=arr=>arr.reduce（（acc，next）=>acc.concat（Array.isArray（next）？flatten（next）：next），[]）常量a=[1，[2，[3，[4]，[5]]]]console.log（flatten（a））

对于N次嵌套数组，具有ES3回退的扁平函数的ES5方式：

var flatten=（函数）{if（！！Array.prototype.reduce&&！！Arrax.isArray）{返回函数（数组）{return array.reduce（函数（prev，next）{return prev.concat（Array.isArray（next）？flatten（next）：next）；}, []);};}其他{返回函数（数组）{var arr=[]；变量i=0；var len=阵列长度；var目标；对于（；i<len；i++）{目标=阵列[i]；arr=arr.concat(（Object.protype.toString.call（target）=='[Object Array]'）？展平（目标）：目标);}返回arr；};}}());var a=[1，[2，[3，[4，[5]]]]；console.log（flatten（a））；

如果您需要支持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);

[1,[2,3],[4,[5,6]]].reduce(function(p, c) {
    return p.concat(c instanceof Array ? 
                    c.reduce(arguments.callee, []) : 
                    [c]); 
}, []);

有一个令人困惑的隐藏方法，它在不改变原始数组的情况下构造一个新数组：

var oldArray=[[1]，[2,3]，[4]；var newArray=Array.prototype.contat.apply（[]，oldArray）；console.log（newArray）；//[ 1, 2, 3, 4 ]