JavaScript 數組展開(扁平化)和underscore的 flatten

原文地址
數組展開就是將嵌套的數組扁平化（轉換爲一維的）eg:

const arr=[[[1, 2], [1, 2, 3]], [1, 2]] => [1, 2, 1, 2, 3, 1, 2] 
console.log(flatten(arr))  //[1,2,1,2,3,1,2]
複製代碼

一、判斷每一項是不是數組，而後遞歸

const arr=[[[1, 2], [1, 2, 3,"a"]], [1, 2,"a"]]
function flatten(arr){
    let result=[]
    for(let i=0,l=arr.length;i<l;i++){
        if(Array.isArray(arr[i])){
            //遞歸調用
            result=result.concat(flatten(arr[i]))  
        }else{
            result.push(arr[i])
        }
    }
    return result
}
console.log(flatten(arr),arr)
複製代碼

二、toString

數組在調用toString()會將數組轉換成"1,2,1,2,3,1,2",再執行split(",")方法會變成["1", "2", "1", "2", "3", "1", "2"] 還須要將全部的參數轉換爲數字，因此這種方式的不足就是若是數組裏面是[1,2,3,"4","5"]既有數字又有字符串，會所有展開爲數字

const arr=[[[1, 2], [1, 2, 3]], [1, 2]]
function flatten(arr){
    return arr.toString().split(",").map(item => {
        //轉爲數字
        return +item
    })
}
console.log(flatten(arr),arr)
複製代碼

三、reduce方法

const arr=[[[1, 2], [1, 2, 3,"a"]], [1, 2,"b"]]
function flatten(arr){
    return arr.reduce((pre,next) => {
        return pre.concat(Array.isArray(next) ? flatten(next) : next)  //若是是數組一樣的遞歸調用
    },[])
}
console.log(flatten(arr),arr)
複製代碼

四、解構的方式

利用es6新增結構方法能夠提取一層的方法，來一層層提取出來

const arr=[[[1, 2], [1, 2, 3,"a"]], [1, 2,"b"]]
function flatten(arr){
    while(arr.some(item => Array.isArray(item))){
        //若是當前數組中還有數組，則展開
        arr=[].concat(...arr)
    }
    return arr
}
console.log(flatten(arr),arr)
複製代碼

五、js原生方法flat

flat(depth) 方法會按照一個可指定的深度遞歸遍歷數組，並將全部元素與遍歷到的子數組中的元素合併爲一個新數組返回。參數depth表示要提取嵌套數組的結構深度,默認爲1

const arr=[[[1, 2], [1, 2, 3,"a"]], [1, 2,"b"]]
arr.flat(Infinity)
複製代碼

六、Underscore.js的flatten方法

先上代碼

/** * param {Array} input 要操做的數組 * param {Boolean} shallow 淺展開，及爲true時，只展開一層，爲false是深度展開 * param {Boolean} strict 遍歷第一層時，是否放棄非數組對象 * param {Array} output 保存最後輸出的內容 */
var flatten = function(input, shallow, strict, output = []) {
  var idx = output.length;
  for (var i = 0, length = getLength(input); i < length; i++) {
    var value = input[i];
    // 說明flatten方法對類數組對象也有支持
    if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
      if (shallow) {
        // 只展開一層
        var j = 0, len = value.length;
        while (j < len) output[idx++] = value[j++];
      } else {
        // 深度迭代,遞歸展開
        flatten(value, shallow, strict, output);
        idx = output.length;
      }
    } else if (!strict) {
      output[idx++] = value;
    }
  }
  return output;
};
複製代碼

output將返回數組看成參數傳遞，能夠省去在遞歸的時候將數據一層層的return到上一層，在性能上會有所提高

當shallow爲false時,strict爲true是，返回的永遠時[] ，這是由於，當shallow爲false時是深度迭代，，當最後迭代到不是數組的時候，就會進入到else if中，若是此時strict爲true則就不會進入到這個分支中，那麼output就永遠不會被操做，