题解 | #9种方法手撕数组去重，涵盖多种数据类型去重#

  // 数组去重的多种方法
  let arr = [
    {},
    {},
    1,
    2,
    2,
    "abc",
    "abc",
    true,
    true,
    false,
    false,
    undefined,
    undefined,
    NaN,
    NaN,
  ];
  
  //  1.set+点运算符
  // Array.prototype.unique = function(){
  //     let arr1 = [...new Set(arr)];
  //     return arr1;
  // }

  // 2. set + Array.from方法（可浅拷贝一个可迭代对象）
  // Array.prototype.unique = function(){
  //     let arr1 = Array.from(new Set(arr));
  //     return arr1;
  // }

  // 3. 声明一个空数组，用includes寻找如果没有该元素则加入新数组
    //         以下三种写法均归为一种思路
  // 写法一：includes方法：[includes底层使用sameValueZero()比较]
    //  Array.prototype.unique = function(){        

  //     const newArray = [];
  //     arr.forEach(item=>{
  //         if(!newArray.includes(item)){
  //             newArray.push(item);
  //         }
  //     })
  //     return newArray;
  // }
  
    //  写法二：利用map的has和set方法（属性名不可重复）
  // Array.prototype.unique = function(){
  //     const newArray = [];
  //     const map = new Map();
  //     arr.forEach(item=>{
  //         if(!map.has(item)){
  //             map.set(item,true);
  //             newArray.push(item);
  //         }
  //     })
  //     return newArray;
  // }
 
    //  写法三：利用对象属性名不可重复
  // Array.prototype.unique = function(){
  //     const newArray = [];
  //     const obj = {};
  //     arr.forEach(item=>{
  //         if(!obj[item]){
  //             obj[item] = true;
  //             newArray.push(item);
  //         }
  //     })
  //     return newArray;
  // }
  // 4.利用reduce方法和includes
  // Array.prototype.unique = function(){
  //     const newArray = arr.reduce((pre,cur)=>{
  //         if(pre.includes(cur) === false){
  //             pre.push(cur);
  //         }
  //         return pre;
  //     },[])
  //     return newArray;
  // }

  // 5.hasOwnProperty方法可以判断类型两个{},{}
  // Array.prototype.unique = function(){
  //     const obj = {};
  //     const newArray = arr.filter(item=>{
  //         return obj.hasOwnProperty(typeof item + item) ? false : obj[typeof item +item] = true
  //     })
        //  typeof {}+{}为object[object Object]，判断有没有空对象，已经有的话return false，没有就作为对象的属性加进去，值为true    
  //     return newArray;
  // }
  // console.log(arr.unique());

  // 下列方法无法判断NaN和NaN重复的情况

  // 6.过滤器filter方法+indexof()方法，indexof会返回第一个找到的索引，如果当前数值之前出现过，
        //    则indexof返回的索引恒为之前的那个数与当前数值的索引不一致，故可以去重
  // Array.prototype.unique = function(){
  //     const newArray = arr.filter((item,index)=>{
  //         return arr.indexOf(item)===index;
  //     })
  //     return newArray;
  // }

  // 7.indexof
  // Array.prototype.unique = function(){
  //     const newArray = [];
  //     arr.forEach(item=>{
  //         if(newArray.indexOf(item)===-1){
  //             newArray.push(item);
  //         }
  //     })
  //     return newArray;
  // }

  // 8.双循环+splice,比较相邻两个数如果重复用splice删除
  // Array.prototype.unique = function(){
  //     let len = arr.length;
  //     for(let i=0;i<len-1;i++){
  //         for(let j=i+1;j<len;j++){
  //             if(arr[i]===arr[j]){
  //                 arr.splice(j,1);
  //                 len--;
  //                 j--;
  //             }
  //         }
  //     }
  //     return arr;
  // }
  // 9.单循环+sort+splice
  // Array.prototype.unique = function(){
  //     let len = arr.length;
  //     arr = arr.sort();
  //     for(let i=0;i<len-1;i++){
  //             if(arr[i]===arr[i+1]){
  //                 arr.splice(i+1,1);
  //                 len--;
  //             }
  //     }
  //     return arr;
  // }