1.雙層迴圈，外層迴圈元素，內層迴圈時比較值；如果有相同的值則跳過，不相同則push進陣列

// formatConcatArr(array)==[ 1, 23, 2, 3 ] 

formatConcatArr(array)=={{formatConcatArr([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

formatConcatArr (array) {
        let arr = array
        let result = []
        let i
        let j
        let len = arr.length
        for (i = 0; i < len; i++) {
          for (j = i + 1; j < len; j++) {
            if (arr[i] === arr[j]) {
              j = ++i
            }
          }
          result.push(arr[i])
        }
        return result
      }
 

2.利用splice直接在原陣列進行操作

雙層迴圈，外層迴圈元素，內層迴圈時比較值；值相同時，則刪去這個值
注意點:刪除元素之後，需要將陣列的長度也減1.（優點：簡單易懂；缺點：佔用記憶體高，速度慢）

// formatConcatArr2(array)==[ 1, 2, 3, 23 ] 

formatConcatArr2(array)=={{formatConcatArr2([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

formatConcatArr2 (array) {
        let arr = array
        let i
        let j
        let len = arr.length
        for (i = 0; i < len; i++) {
          for (j = i + 1; j < len; j++) {
            if (arr[i] === arr[j]) {
              arr.splice(j, 1)
              len--
              j--
            }
          }
        }
        return arr
      }
 

3.利用物件的屬性不能相同的特點進行去重

// formatConcatArr3(array)==[ 1, 2, 3, 23 ] 

formatConcatArr3(array)=={{formatConcatArr3([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

formatConcatArr3 (array) {
        let arr = array
        let i
        let obj = {}
        let result = []
        let len = arr.length
        for (i = 0; i < len; i++) {
          // 如果能查詢到，證明陣列元素重複了
          if (!obj[arr[i]]) {
            obj[arr[i]] = 1
            result.push(arr[i])
          }
        }
        return result
      }

4.陣列遞迴去重；運用遞迴的思想， 先排序，然後從最後開始比較，遇到相同，則刪除

// formatConcatArr4(array)==[ 1, 2, 3, 23 ] 

formatConcatArr4(array)=={{formatConcatArr4([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

formatConcatArr4 (array) {
        let arr = array
        let len = arr.length
        // 對陣列進行排序才能方便比較
        arr.sort(function (a, b) {
          return a - b
        })
        function loop (index) {
          if (index >= 1) {
            if (arr[index] === arr[index - 1]) {
              arr.splice(index, 1)
            }
            // 遞迴loop函式進行去重
            loop(index - 1)
          }
        }

        loop(len - 1)
        return arr
      }

5.利用indexOf以及forEach

// formatConcatArr5(array)==[ 1, 23, 2, 3 ] 

formatConcatArr5(array)=={{formatConcatArr5([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

formatConcatArr5 (array) {
  let arr = array
  let result = []
  let len = arr.length
  if (len > 0) {
    // 這裡利用map，filter方法也可以實現
    arr.forEach(function (v, i, arr) {
      // 從傳入引數的下一個索引值開始尋找是否存在重複
      let bool = arr.indexOf(v, i + 1)
      if (bool === -1) {
        result.push(v)
      }
    })
  }
  return result
}

6.利用ES6的set：

1.Set資料結構，它類似於陣列，其成員的值都是唯一的。利用Array.from將Set結構轉換成陣列
// formatDedupeArr(array)==[ 1, 2, 3, 23 ] 
　

formatDedupeArr(array)=={{formatDedupeArr([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3])}}

 formatDedupeArr (array) {
        return Array.from(new Set(array))
      }

2.擴充套件運算子和 Set 結構相結合，就可以去除陣列的重複成員。擴充套件運算子（...）內部使用for...of迴圈，所以也可以用於 Set 結構。 // formatDedupeArr2()==[ 1, 2, 3, 23 ]

formatDedupeArr2()=={{formatDedupeArr2()}}

formatDedupeArr2 () {
   let arr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 2, 2, 1, 23, 1, 23, 2, 3, 2, 3, 2, 3]
  let resultarr = [...new Set(arr)]
  console.log(resultarr) // [1,2,3,23]
  return resultarr
}