1. 利用Set的特性(ES6):转化为set集合,set里面会自动去重,然后再把set集合转换为数组

var  arr = [11,21,312,5,53,536,47,676,54,11,22,33,312,53,47];
    function unique(arr){
        console.log(arr)  //[11, 21, 312, 5, 53, 536, 47, 676, 54, 11, 22, 33, 312, 53, 47]
        var newSet = new Set(arr)
        var newArr = Array.from(newSet)
        console.log("set特性去重:"+newArr)  //set特性去重:11,21,312,5,53,536,47,676,54,22,33
        console.log(newArr.sort())  //[11, 21, 22, 312, 33, 47, 5, 53, 536, 54, 676]
        return newArr;
    }
  unique(arr)

2. indeOf()索引查询法:声明一个新数组,依次遍历参数数组,获取参数数组的每一个元素在新数组的索引,若为-1,则表示,没有在新数组中,就把它添加到新数组中,最后返回新数组;

var  arr = [11,21,312,5,53,536,47,676,54,11,22,33,312,53,47];
      function unique(arr){
        var newArr = [];
        for(let i = 0;i<arr.length;i++){
            if(newArr.indexOf(arr[i]) == -1){
                newArr.push(arr[i])
            }
        }
        console.log(newArr.sort(function(a,b){
            return a - b;
        })) ///[5, 11, 21, 22, 33, 47, 53, 54, 312, 536, 676]
        return newArr;
    }
   unique(arr)

3. indexOf()下标判断法:声明一个新的数组,遍历参数数组,一次查询每个元素的第一次出现时的下标,若一致,则表示该元素第一次出现,放入新数组,最后返回新数组;

var  arr = [11,21,312,5,53,536,47,676,54,11,22,33,312,53,47];
       function unique(arr){
        var newArr = [];
        for(let i = 0;i<arr.length;i++){
            if(arr.indexOf(arr[i]) == i){
                newArr.push(arr[i])
            }
        }
        return newArr;
    }

4. indexOf():遍历数组,判断元素第一次出现时的索引和最后一次出现的索引一致不,不一致则说明有重复的元素,选择删除当前后者后边的元素;

        function unique(arr){
            for (let i = 0; i < arr.length; i++) {
                if(arr.indexOf(arr[i]) != arr.lastIndexOf(arr[i])){
                    arr.splice(arr.indexOf(arr[i]),1);//删除当前元素
                    // arr.splice(arr.lastIndexOf(arr[i]),1); //删除后边的元素
                    i--;
                }
            }
            return arr;
        }

5. 相邻去除法:这个方法用到了sort()方法,先把数组从小到大排序,然后以去除相邻重复的就行了;

var  arr = [11,21,312,5,53,536,47,676,54,11,22,33,312,53,47];
      function unique(arr){
        arr.sort(function(a,b){
            return a - b;
        })
        var newArr = [arr[0]];
        for(let i = 0;i<arr.length;i++){
            if(arr[i] != newArr[newArr.length - 1]){
                newArr.push(arr[i])
            }
        }
        return newArr;
    }

6. 双层循环:外层循环元素,内层循环进行比较,值相同,则删除这个值

var  arr = [11,21,312,5,53,536,47,676,54,11,22,33,312,53,47];
      function unique(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--; //删除一个元素之后,数组长度变短,删除元素的后边元素都往前移动了一个位置,所以要遍历下一个元素需要索引-1
                    }
                }             
            }
            return arr;
        }

7. includes:查看当前数组时候包含指定的元素,跟indexOf()有类似的作用,indexOf返回的是索引,includes返回的是Boolean值

    function unique(arr){
     var newArr = [];
      for (let i = 0; i < arr.length; i++) {
         if(!newArr.includes(arr[i])){
              newArr.push(arr[i])
          }
       }
        return newArr;
     }   
    console.log(unique(arr))
    console.log(unique([1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}]))  
    

8.递归去重:

      function unique(arr){
            arr.sort(function(a,b){
                return a - b;
            });
            function loop(index){
                if(index>1){
                    if(arr[index] == arr[index-1]){
                        arr.splice(index,1)
                    }
                    loop(index -1)
                }
            }
            loop(arr.length-1);
            return arr;
        }