JS（ES6）去除数组中的重复记录

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
}