数组去重的几种方式详解

方法一：

Set() （最为推荐的方法）

Set是一种有序列表，并且它的值没有重复

利用Set类型数据无重复项：new  Set，参数为需要去重的数组，Set 会自动删除重复的元素，再将 Set 转为数组返回。这个方法的优点是效率更高，代码简单，思路清晰，缺点是可能会有兼容性问题

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(arr) {
            return [...new Set(arr)]
        }
        console.log(test(arr))

输出结果：

 方法二：

filter()和indexOf()

filter()方法会创建一个新数组，原数组的每个元素都传入回调函数中，回调函数中有return返回值。若返回值为true，则这个元素保存在新数组中；若返回值为false，则该元素不保存到新数组中。

利用 Array 自带的 filter 方法，返回 arr.indexOf(item,0) 等于 index 。原理就是 indexOf 会返回最先找到的数字的索引，假设数组是 [1, 1]，在对第二个1使用 indexOf 方法时，返回的是第一个1的索引0。这个方法的优点是可以在去重的时候插入对元素的操作，可拓展性强。

array.filter(function(currentValue,index,arr), thisValue)

currentValue ---必选。表示元素的值

index ---当前元素的索引值

arr ---当前元素属于的数组对象

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(arr) {
            return arr.filter(function(item,index) {
                return arr.indexOf(item,0) === index
            })
        }
        console.log(test(arr))

输出结果： 

 

方法三：

Map()

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(arr) {
            let map = new Map()
            let arr1 = []
            for(let i = 0, len = arr.length; i < len; i++) {
                if(map.has(arr[i])) {
                    map.set(arr[i], true)
                }
                else{
                map.set(arr[i], false)
                arr1.push(arr[i])
                }
            }
            return arr1
        }
console.log(test(arr))

输出结果： 

 

方法四：

includes()

arr.includes(指定元素(必填),指定索引值(可选,默认值为0) )，有值返回true，没有则返回false

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(arr) {
            let arr1 = []
            for(let i = 0; i < arr.length; i++) {
                if(!arr1.includes(arr[i])) {
                    arr1.push(arr[i])
                }
            }
            return arr1
        }
console.log(test(arr))

输出结果： 

方法五：

hasOwnProperty

这个方法因为是直接操作数组，占用内存较少。

这里的typeof item + item可以输出"item数据类型 + item值"的字符串结果，然后通过hasOwnPrototype()来判断obj内是否有这个数据类型的数据（hasOwnPrototype()不会攀升原型链），如果有那么就直接返回false，根据filter()的用法，这个数据就会被过滤掉。

如果这个obj内没有这个类型的数据，那么就会通过obj[数据类型]的方式将这个类型存入obj中，并且设定值为true，同时这个数据根据filter()的用法，会保留。

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(arr) {
            let obj = {}
            let res = arr.filter(item => {
                if(obj.hasOwnProperty(typeof item + item)) {
                    return false
                }else {
                    obj[typeof item + item] = true
                    return true
                }
            })
            return res
        }
console.log(test(arr))

 输出结果： 

方法六：

双重for循环，splice()去重

let arr = [1,2,2,3,5,8,8,0,2,1]
        function test(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(test(arr))

  输出结果：