数组去重12种方法

数组去重12种方法

方法一：Set 不是一种数据类型，是一种数据结构；成员唯一(ES6中最常用)

function unique(arr) {
  return  Array.from(new Set(arr)) // Array.from : 将set数据结构转成真正的数组；
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法二：类似于方法一的set，用了剩余运算符…

let arr =[10,13,10,3,13,99,55,9,55];
let a = [...new Set(arr)];
console.log(a);

方法三：indexOf新建一个空的结果数组，for 循环原数组，判断结果数组是否存在当前元素，如果有相同的值则跳过，不相同则push进数组

function unique(ary) {
 if (!Array.isArray(ary)) { 
   console.log('type error!') 
   return 
  } 
  let newAry = [];
  for(let i=0;i<ary.length;i++){
   let  cur = ary[i];
    if(newAry.indexOf(cur)===-1){
      newAry.push(cur);
    }
  }
  return newAry;
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法四：filter返回一个过滤后的新数组；如果返回true就留下，false就过滤掉

function unique(ary) {
  return ary.filter(function (item,index,a) {
    return ary.indexOf(item)===index;
  })
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法五：includes方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false

function unique(ary) {
 if (!Array.isArray(ary)) { 
    console.log('type error!') 
    return 
  } 
  let newAry = [];
  let len = ary.length;
  for(let i=0;i<len;i++){
   let cur = ary[i];
    if(!newAry.includes(cur)){
      newAry.push(cur);
    }
  }
  return newAry;
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法六：hasOwnProperty 检测属性名是否是对象的一个私有属性;返回一个布尔值；

function unique(ary) {
  let obj = {};
  return ary.filter(function (item,index,a) {// a : 整个数组
     return  obj.hasOwnProperty(typeof item+item)?false:obj[typeof item+item]=true;// hasOwnProperty来校验的该属性是否出现过；
  })
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法七：sort

function unique(ary) {
 if (!Array.isArray(ary)) { 
    console.log('type error!') 
    return; 
  } 
  let a = ary.sort(function (a,b) {
    return a-b;
  });
  for(let i=0;i<a.length;i++){
    if(a[i]===a[i+1]){
       a.splice(i+1,1);
       i--;
     }
  }
  return a;
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法八：递归

function unique(ary) {
  let  len= ary.length;
  ary = ary.sort(function (a,b) {
   return a-b;
  });
  function loop(index) {
   if(index>=1){
     if(ary[index]===ary[index-1]){
       ary.splice(index,1);
     }
     loop(index-1)
    }
  }
  loop(len-1);
  return ary;
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法九：splice双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值

function unique(ary) {
  for(let i=0;i<ary.length;i++){
    for(j=i+1;j<ary.length;j++){
      if(ary[i]===ary[j]){ //第一个等同于第二个，splice方法删除第二个   
       	ary.splice(j,1);
       	j--;
       }
     }
  }
  return ary;
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法十：Map创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果

function unique(ary) {
  let newAry =new Array();   
  let map = new Map();
  for(let i=0;i<ary.length;i++){
    if(map.has(ary[i])) {  
      map.set(ary[i], true); // 如果有该key值  
    } else { 
      map.set(ary[i], false); // 如果没有该key值  
      newAry.push(ary[i]); 
    } 
  }
   return newAry  ; 
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法十一：利用reduce+includes

function unique(ary) {
  return ary.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);
}
var arr = [10,13,10,3,13,99,55,9,55];
console.log(unique(arr)) 

方法十二：some返回一个布尔值，只要一个是true，就返回true

let arr = [10,13,10,3,13,99,55,9,55];
var newArr = [];
for (let i = 0; i < arr.length; i++) {
  if (newArr.some(item => item == arr[i])) {
    continue; // 继续循环
  }
  newArr.push(arr[i]);
}
console.log(newArr);