利用对象的属性不能相同的特点进行去重

var arr = [1, 6, 4, 6, 6, 4, 2, "a", "a"];
var res = [];
var obj = {};
for (var i = 0; i < arr.length; i++) {
  if (!obj[arr[i]]) {
    obj[arr[i]] = true;
    res.push(arr[i]);
  }
}
console.log(res); //[1, 6, 4, 2, "a"]

双重循环 

使用额外数组

var arr = [1, 6, 4, 6, 6, 4, 2, "a", "a"];
var res = [];
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < res.length; j++) {
    if (arr[i] == res[j]) {
      break;
    }
  }
  //如果这两个数相等说明循环完了,没有相等的元素
  if (j == res.length) {
    res.push(arr[i]);
  }
}
console.log(res); //[1, 6, 4, 2, "a"]

利用splice

双指针遍历，splice操作会改变原始数组，注意下标

for(i = 0;i<arr.length-1;i++){
    for(j = i+1;j<arr.length;){
        if(arr[i] == arr[j]){
            arr.splice(j,1)
         }else{
            j++;
         }
      }
}

利用sort

arr.sort((a,b)=>{
    return a-b;
 })
for(let i = 0;i <arr.length-1;i++){
    if(arr[i]==arr[i+1]){
        arr.splice(i+1,1)
        i--; //注意
    }
}

// 使用额外数组
var newArr = [];
arr = arr.sort();
for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== arr[i+1]) {
        newArr.push(arr[i])
    }
}
console.log(newArr);

利用 for/forEach/filter()和 indexOf()

for+indexOf

var res = [];
for (var i = 0; i < arr.length; i++) {
  if (res.indexOf(arr[i]) == -1) {
    res.push(arr[i]);
  }
}
console.log(res); 

forEach+indexOf

var res = [];
arr.forEach(function(item, index) {
  if (res.indexOf(item) == -1) {
    res.push(item);
  }
});
console.log(res); 

filter+indexOf

var res = arr.filter(function(item, index) {
  return arr.indexOf(item) == index;
});
console.log(res); 

ES6 的 new Set()实现去重

var arr = [1, 6, 4, 6, 6, 4, 2, "a", "a"];
//第一种
var newarr = Array.from(new Set(arr));
console.log(newarr); //[1, 6, 4, 2, "a"]
//第二种
var newarr1 = [...new Set(arr)];
console.log(newarr1); //[1, 6, 4, 2, "a"]

ES6 的 includes 实现去重

var arr = [1, 6, 4, 6, 6, 4, 2, "a", "a"];
var res = [];
arr.forEach(function(item, index) {
  if (!res.includes(item)) {
    res.push(item);
  }
});
console.log(res); //[1, 6, 4, 2, "a"]

利用map实现去重

let map = new Map()
let newArr = []
arr.forEach(ele => {
    if (!map.has(ele)) {
        map.set(ele, 1)
        newArr.push(ele)
    }
});

利用reduce实现去重

let res = (arr) =>{
    let newArr = []
    arr.reduce((pre, next)=>{
      if(!pre.get(next)){
        pre.set(next, 1)
        newArr.push(next)
      }
      return pre
    },new Map())
    return newArr.sort((a, b) => {
        return a - b
    })
}
console.log(res(arr))

利用递归

var arr = [3, 4, 5, 2, 3, 1, 1, 2];
        function unique(arr){
            var newArr = arr;
            
            //先排序
            newArr.sort((a,b) => {
                return a - b;
            });
            function loop(index){
                if (index >= 1) {
                    if (newArr[index] == newArr[index-1]) {
                        newArr.splice(index,1);//有相等的 则删除后一个
                    }
                    loop(index-1);//递归
                }
            }
            loop(newArr.length-1);
            return newArr
        }
        console.log(unique(arr));