1、利用ES6中 Set去重

ES6提供了新的数据结构Set，Set函数可以接受一个数组（或类数组对象）作为参数来初始化。
Array.from方法可以将Set结构转换为数组结果，而Set结果是不重复的数据集，因此能够去重。

2、利用ES6中 Set 和解构赋值去重

…扩展运算符 （…可用来转换为数组对象）

问题：因为js是判断对象地址是否相同，而不是对象内容，所以每个空对象都是不相等的。

缺点：存在兼容性问题，不支持IE

3、利用for嵌套for双重循环，然后splice去重（ES5中常用）

splice()方法向、从数组中添加、删除项目，然后返回被删除的项目，会改变原始数组
splice()方法可删除从index处开始的零个或多个元素

 function unique(arr) {
    
            for (var i = 0; i < arr.length; i++) {
    
                for (var j = i + 1; j < arr.length; j++) {
    
                    if (arr[i] == arr[j]) {
             //第一个等同于第二个，splice方法删除第二个
                        arr.splice(j, 1);
                        j--;
                    }
                }
            }
            return arr;
        }
        var arr=[1,1,2,4,true,true,false,false,null,null,"af","he","af",undefined,undefined,{
    },{
    },NaN,NaN];
        console.log(unique(arr));
        //[1,2,4,false,"af","he",undefined,{},{},NaN,NaN]    

问题：NaN和 {} 没有去重，两个null和两个true直接消失了
null消失:改为===即可

function unique(arr) {
    
            for (var i = 0; i < arr.length; i++) {
    
                for (var j = i + 1; j < arr.length; j++) {
    
                    if (arr[i] == arr[j]) {
             //第一个等同于第二个，splice方法删除第二个
                        arr.splice(j, 1);
                        j--;
                    }
                }
            }
            return arr;
        }
        var arr=[1,1,2,4,true,true,false,false,null,null,"af","he","af",undefined,undefined,{
    },{
    },NaN,NaN];
        console.log(unique(arr));
        //[1,2,4,true,false,null,"af","he",undefined,{},{},NaN,NaN]

严格相等===：两个被比较的值类型相同，值也相同，两个被比较的值在比较前都不进行隐式转换
非严格相等==：在比较前将两个被比较的值转换为相同类型

4、利用indexOf去重

数组的indexOf方法可以返回某个指定的元素在数组中首次出现的位置。

1.创建一个空的结果数组，for循环原数组，然后调用indexOf方法对原来的数组进行遍历判断，如果元素不在结果数组中，则将其push进结果数组中，最后将结果数组返回，即可得到去重的数组。

function unique(arr) {
    
            if (!Array.isArray(arr)) {
    
                console.log('type error!')
                return
            }
            let res = []
            for (let i = 0; i < arr.length; i++) {
    
                if (res.indexOf(arr[i]) === -1) {
        //判断arr中的元素是否在结果数组中
                    res.push(arr[i])
                }
            }
            return res
        }
        var arr=[1,1,2,4,true,true,false,false,null,null,"af","he","af",undefined,undefined,{
    },{
    },NaN,NaN];
        console.log(unique(arr));
        //[1,2,4,true,false,null,"af","he",undefined,{},{},NaN,NaN]

*2.利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等，如果不等则说明该元素是重复元素。

function unique(arr) {
    
            if (!Array.isArray(arr)) {
    
                console.log('type error!')
                return
            }
            return Array.prototype.filter.call(arr, function (item, index) {
    
                return arr.indexOf(item) === index;
            });
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //[1,2,4,true,false,null,"af","he",undefined,{},{}]

5、利用sort()去重

利用sort()排序方法，然后根据排序后的结果进行遍历及相邻元素比对。

function unique(arr) {
    
            if (!Array.isArray(arr)) {
    
                console.log('type error!')
                return
            }
            arr = arr.sort();
            var array = [arr[0]];
            //遍历排序后的数组
            for (var i = 1; i < arr.length; i++) {
    
                if (arr[i] !== arr[i - 1]) {
       //判断相邻元素是否相等
                    array.push(arr[i]);
                }
            }
            return array
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //[1,2,4,NaN,NaN,{},{},"af",false,"he",null,true,undefined]

6、利用数组原型对象中的includes方法

includes方法可用来检测数组是否含有某个值

function unique(arr) {
    
            if (!Array.isArray(arr)) {
    
                console.log('type error!')
                return
            }
            var array = [];
            for (var i = 0; i < arr.length; i++) {
    
                if (!array.includes(arr[i])) {
       //includes 检测数组是否有某个值
                    array.push(arr[i]);
                }
            }
            return array
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //12 [1,2,4,true,false,null,"af","he",undefined,{},{},NaN]

此时NaN也去重了

7、利用数组原型对象中的filter+includes

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。filter不会改变原始数组。利用fifter进行遍历

function unique(arr) {
    
            var newArr = []
            newArr = arr.filter(function (item) {
    
                return newArr.includes(item) ? '' : newArr.push(item)
            })
            return newArr
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //12 [1,2,4,true,false,null,"af","he",undefined,{},{},NaN]
        //与includes去重原理一致

8、利用数组原型对象中的forEach+includes

forEach方法：循环遍历数组中的每一项。
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map()方法按照原始数组元素顺序依次处理元素
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。没有符合条件的元素时返回空数组。
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

function unique(arr) {
    
            var newArr = []
            arr.forEach(item => {
    
                return newArr.includes(item) ? '' : newArr.push(item)
            });
            return newArr
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //12 [1,2,4,true,false,null,"af","he",undefined,{},{},NaN]
        //与includes去重原理一致

9、利用filter

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

function unique(arr) {
    
            return arr.filter(function (item, index, arr) {
    
                //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
                return arr.indexOf(item, 0) === index;
            });
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //11 [1,2,4,true,false,null,"af","he",undefined,{},{}]

10、利用对象的hasOwnProperty(推荐)

Object的hasOwnProperty()方法返回一个布尔值，判断对象是否包含特定的自身（非继承）属性。

function unique(arr) {
    
            var obj = {
    };
            return arr.filter(function (item, index, arr) {
    
                return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
            })
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //11 [1,2,4,true,false,null,"af","he",undefined,{},NaN]
        //所有的都去重了

11、利用递归去重

可用for循环替代

function unique(arr) {
    
            var array = arr;
            var len = array.length;
            array.sort(function (a, b) {
       //排序后更加方便去重
                return a - b;
            })
            function loop(index) {
    
                if (index >= 1) {
    
                    if (array[index] === array[index - 1]) {
    
                        array.splice(index, 1);
                    }
                    loop(index - 1);    //递归loop，然后数组去重
                }
            }
            loop(len - 1);
            return array;
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
       //14 [false,null,1,true,2,4,"af","he","af",NaN,NaN,{}，{}，undefined]

12、利用Map数据结构去重

map是ES提供的一种字典数据结构
字典结构——用来存储不重复key的hash结构。不同于集合（set）的是，字典使用的是键值对的形式来存储数据

function unique(arr) {
    
            let map = new Map();
            let array = new Array();  // 数组用于返回结果
            for (let i = 0; i < arr.length; i++) {
    
                if (map.has(arr[i])) {
      // 如果有该key值
                    map.set(arr[i], true);
                } else {
    
                    map.set(arr[i], false);   // 如果没有该key值
                    array.push(arr[i]);
                }
            }
            return array;
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //12 [1, 2,4,true,false,null,"af","he",undefined,{},{},NaN]

13、利用reduce+includes去重

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

function unique(arr) {
    
            return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //12 [1,2,4,true,false,null,"af","he",undefined,{},{},NaN]

14、利用对象属性去重

创建空对象，遍历数组，将数组中的值设为对象的属性，并给该属性赋初始值1，每出现一次，对应的属性值增加1，这样，属性值对应的就是该元素出现的次数了

function unique(arr) {
    
            if (!Array.isArray(arr)) {
    
                console.log('type error!')
                return
            }
            let res = [],
                obj = {
    }
            for (let i = 0; i < arr.length; i++) {
    
                if (!obj[arr[i]]) {
    
                    res.push(arr[i])
                    obj[arr[i]] = 1
                } else {
    
                    obj[arr[i]]++
                }
            }
            return res
        }
        var arr = [1, 1, 2, 4, true, true, false, false, null, null, "af", "he", "af", undefined, undefined, {
    }, {
    }, NaN, NaN];
        console.log(unique(arr));
        //11 [1,2,4,true,false,null,"af","he",undefined,{},NaN]