ES6：数组去重的方法

结论先行：

① 使用 Set 数据结构：因为该结构中的元素是唯一的，不允许重复

将数组转换为 Set，然后再将 Set 转换回数组来实现去重

② 使用 filter() 方法：遍历数组，筛选出不重复的元素

③ 使用 reduce() 方法：遍历数组，将不重复的元素添加到累积的结果数组中

④  for 循环嵌套，利用 splice 去重

⑤ 新建数组，利用 includes 去重

⑥ 先用 sort 排序，然后用一个指针从第0位开始，配合 while 循环去重

具体解析：

1、使用Set数据结构

Set 是 ES6 引入的一种数据结构，其中的元素是唯一的，不允许重复。可以通过将数组转换为Set，然后再将 Set 转换回数组来实现去重。

[...new Set(array)]

const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // 输出 [1, 2, 3, 4, 5]

Array.from(new Set(array))

var arr = [1, 1, 2, 2, 3, 4, 5, 5, 4, 3, 2, 1]
// Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
console.log(Array.from(new Set(arr))) // [1, 2, 3, 4, 5]

2、使用 filter() 方法

利用 filter() 方法遍历数组，筛选出不重复的元素

const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = array.filter((element, index, self) => {
  return self.indexOf(element) === index;
});
console.log(uniqueArray); // 输出 [1, 2, 3, 4, 5]

3、使用 reduce() 方法

使用 reduce() 方法遍历数组，将不重复的元素添加到累积的结果数组中。

const array = [1, 2, 2, 3, 4, 4, 5];
const uniqueArray = array.reduce((accumulator, currentValue) => {
  if (!accumulator.includes(currentValue)) {
    accumulator.push(currentValue);
  }
  return accumulator;
}, []);
console.log(uniqueArray); // 输出 [1, 2, 3, 4, 5]

4、for循环嵌套，利用 splice 去重

具体实现： 

function uniqueArr(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) {
                arr.splice(j, 1)
                j--
            }
        }
    }
    return arr
}
console.log(uniqueArr([1, 1, 2, 2, 3, 4, 5, 5, 4, 3, 2, 1])) // [1, 2, 3, 4, 5]
console.log(uniqueArr([1, 1, 2, 5, 6, 3, 5, 5, 6, 8, 9, 8])) //  [1, 2, 5, 6, 3, 8, 9]

5、新建数组，利用 includes 去重

具体实现： 

function uniqueArr(arr) {
    let resArr = []
    arr.forEach(item => {
        if (!res.includes(item)) {
            res.push(item)
        }
    });
    return resArr
}
console.log(uniqueArr([1, 1, 2, 2, 3, 4, 5, 5, 4, 3, 2, 1])) // [1, 2, 3, 4, 5]

6、先用 sort 排序，然后用一个指针从第0位开始，配合 while 循环去重

具体实现： 

        function uniqueArr(arr) {
            arr.sort()
            let pointer = 0
            while (arr[pointer]) {
                if (arr[pointer] == arr[pointer + 1]) {
                    // 删除下一项
                    arr.splice(pointer + 1, 1)
                } else {
                    // 指针往下移
                    pointer++
                }
            }
            return arr
        }
        console.log(uniqueArr([1, 1, 2, 2, 3, 4, 5, 5, 4, 3, 2, 1]))
        console.log(uniqueArr([1, 1, 2, 5, 6, 3, 5, 5, 6, 8, 9, 8]))