[[436474]]

數組扁平化(又稱數組降維)

MDN：flat() 方法會按照一個可指定的深度遞歸遍歷數組，并將所有元素與遍歷到的子數組中的元素合并為一個新數組返回。

const test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]] 
 
// 不傳參數時，默認扁平化一層 
test.flat() 
// ["a", "b", "c", "d", ["e", ["f"]], "g"] 
 
// 傳入一個整數參數，整數即扁平化的層數 
test.flat(2) 
// ["a", "b", "c", "d", "e", ["f"], "g"] 
 
// Infinity 關鍵字作為參數時，無論多少層嵌套，都會轉為一維數組 
test.flat(Infinity) 
// ["a", "b", "c", "d", "e", "f", "g"] 
 
// 傳入 <=0 的整數將返回原數組，不扁平化 
test.flat(0) 
test.flat(-10) 
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]] 
 
// 如果原數組有空位，flat()方法會跳過空位。 
["a", "b", "c", "d",,].flat() 
// ["a", "b", "c", "d"] 

Array.prototype.flat() 特性總結：

• Array.prototype.flat() 用于將嵌套的數組扁平化，變成一維的數組。該方法返回一個新數組，對原數據沒有影響。
• 不傳參數時，默認扁平化一層，可以傳入一個整數，表示想要扁平化的層數。
• 傳入 <=0 的整數將返回原數組，不扁平化。
• Infinity 關鍵字作為參數時，無論多少層嵌套，都會轉為一維數組。
• 如果原數組有空位，Array.prototype.flat() 會跳過空位。

方法一：使用 reduce 方法

一次性扁平化所有：

function flattenDeep(arr) {  
    return Array.isArray(arr) 
      ? arr.reduce( (acc, cur) => [...acc, ...flattenDeep(cur)] , []) 
      : [arr] 
} 
 
// 測試 
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]] 
flattenDeep(test) 
// ["a", "b", "c", "d", "e", "f", "g"] 

實現 flat 函數：

function flat(arr, depth = 1) { 
    return depth > 0 
        ? arr.reduce((acc, cur) => { 
        if(Array.isArray(cur)) { 
            return [...acc, ...flat(cur, depth-1)] 
        } 
        return [...acc, cur] 
    } , []) 
      : arr 
} 
 
// 測試 
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]] 
// 不傳參數時，默認扁平化一層 
flat(test) 
// ["a", "b", "c", "d", ["e", ["f"]], "g"] 
 
// 傳入一個整數參數，整數即扁平化的層數 
flat(test, 2) 
// ["a", "b", "c", "d", "e", ["f"], "g"] 
 
// Infinity 關鍵字作為參數時，無論多少層嵌套，都會轉為一維數組 
flat(test, Infinity) 
// ["a", "b", "c", "d", "e", "f", "g"] 
 
// 傳入 <=0 的整數將返回原數組，不扁平化 
flat(test, 0) 
flat(test, -10) 
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]; 
 
// 如果原數組有空位，flat()方法會跳過空位。 
var arr = ["a", "b", "c", "d",,] 
flat(arr) 
// ["a", "b", "c", "d"] 

方法二：棧

一次性降維所有

function flattenDeep(arr) { 
  const result = []  
  // 將數組元素拷貝至棧，直接賦值會改變原數組 
  const stack = [...arr] 
  // 如果棧不為空，則循環遍歷 
  while (stack.length !== 0) { 
    const val = stack.pop()  
    if (Array.isArray(val)) { 
      // 如果是數組再次入棧，并且展開了一層 
      stack.push(...val)  
    } else { 
      // 如果不是數組，就用頭插法插入到結果數組中 
      result.unshift(val) 
    } 
  } 
  return result 
} 
 
// 測試 
var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]] 
flattenDeep(animals) 
// ["a", "b", "c", "d", "e", "f", "g"] 

數組去重

方式一：Set(ES6)

function unique(arr) { 
    return Array.from(new Set(arr)) 
} 
// 或者 
var unique = arr => [...new Set(arr)] 
 
// 測試 
var arr = [1, 2, 2, 3] 
unique(arr); // [1, 2, 3] 

方式二：reduce

function unique (arr) { 
    return arr.sort().reduce((acc, cur) => { 
     if (acc.length === 0 || acc[acc.length - 1] !== cur) { 
         acc.push(cur); 
     } 
     return acc 
 }, [])} 
; 
 
// 測試 
var arr = [1, 2, 2, 3] 
unique(arr); // [1, 2, 3] 

方法三：filter

function unique(arr) {  
    return arr.filter( (element, index, array) => { 
     return array.indexOf(element) === index 
 }) 
} 
 
// 測試 
var arr = [1, 2, 2, 3] 
unique(arr); // [1, 2, 3]