前言

数组扁平化，就是将多层嵌套数组转换后，只有一层

var arr = [1, 2, [3, [4, 5]]];

flatten(arr);// [1, 2, 3, 4, 5];

递归+concat

利用concat将数组合并

function flatten(array){
    let result = [];

    for(let i = 0, len = array.length; i < len; i++){
        let value = array[i];

        if(Array.isArray(value)){
            result = result.concat(flatten(array[i]))
        } else {
            result.push(value);
        }
    }
    console.log(result)
    return result;
}

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

reduce

function flatten(array) {
    return array.reduce(function(prev, next){
        return prev.concat(Array.isArray(next) ? flatten(next) : next);
    }, []);
}

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

es6扩展运算符

用这种方法只可以扁平一层

var arr = [1, [2, [3, 4]]];
console.log([].concat(...arr)); // [1, 2, [3, 4]]

function flatten3(array){
    while (array.some(item=> Array.isArray(item))) {
        array = [].concat(...array);
    }
    return array;
}

参照undercore

/**
 * 数组扁平化
 * @param  {Array} input   要处理的数组
 * @param  {boolean} shallow 是否只扁平一层
 * @param  {boolean} strict  是否严格处理元素，去掉非数组元素
 * @param  {Array} output  这是为了方便递归而传递的参数
 * 源码地址：https://github.com/jashkenas/underscore/blob/master/underscore.js#L528
 */
function flatten(array, shallow, strict, output) {

    output = output || [];

    for(let i = 0, len = array.length; i < len; i++){
        let value = array[i];

        if(Array.isArray(value)){
            if(shallow) {
                let j = 0;
                    length = value.length;

                while (j < length) {
                    output.push(value[j++]);
                }
            } else {
                output = flatten(value, shallow, strict, output);
            }
        } else if(!strict){
            output.push(value);
        }
    }
    return output;
}

es6的flat

flat不传参，默认是一层

[1,[2,[3]]].flat(Infinity)

参考：github.com/mqyqingfeng…