利用ES6的 set进行去重

    1. const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
    3. console.log([...new Set(numbers)])

    利用for循环嵌套，splice去重
    优点：可区分“1” 和 1
    缺点 : 对象不可以去重 因为对象不可以用来比较 NaN不可以去重

    1. let unique = arr =>{
    2.     for(let i=0;i<arr.length;i++){
    3.         for(let j=i+1;j<arr.length;j++){
    4.             if(arr[i] === arr[j]){
    5.                 arr.splice(j,1);
    6.                 j = j-1;
    7.             }
    8.         }
    9.     }
    10.     return arr 
    11. }

    利用indexOf去重
    优点：可区分”1” 和 1 缺点：NaN和对象 不可去重

    1. //IndexOf()从字符串中第一个字符开始检索,返回值都是字符串中字符所在的下标，如果没有找到则返回-1
    2. let unique = arr =>{
    3.     let array = [];
    4.     for(let i =0;i<arr.length;i++){
    5.         if(array.indexOf(arr[i]) === -1){
    6.             array.push(arr[i])
    7.         }
    8.     }
    9.     return array
    10. }

    利用sort( )去重
    优点：NaN可去重 缺点：对象不可去重

    1. //利用sort进行排序  然后进行去重
    2. let unique = arr =>{
    3.     arr = arr.sort()
    4.     let array = [arr[0]];
    5.     for(let i =1;i<arr.length;i++){
    6.         if(arr[i] !== arr[i-1]){
    7.             array.push(arr[i])
    8.         }
    9.     }
    10.     return array
    11. }

    使用Map数据结构去重
    优点：可以实现NaN去重 缺点：对象不可去重

    1. //mapObj.set(key, value)    
    2. //key：必需,新元素的键     value：必需,要添加的元素的值
    3. let unique = arr =>{
    4.     let map = new Map()
    5.     let array = new Array()
    6.     for(let i=0;i<arr.length;i++){
    7.         if(map.has(arr[i])){
    8.             map.set(arr[i],true)
    9.                 }else{
    10.         map.set(arr[i],false)    
    11.         array.push(arr[i])}
    12.     }
    13.     return array 
    14. }