利用ES6 Set去重

  1. function unique(arr) {
  2.     return Array.from(new Set(arr))
  3. }

使用ES6语法，Set结构下数据不能重复的特点

利用for嵌套for, 然后splice去重

  1. function 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--;
  7.       }
  8.     }
  9.   }
  10.   return arr;
  11. }

双层for循环，直接修改原数组，将重复的数剔除

利用idexOf()去重

  1. function unique1(arr){
  2.     let array = [];
  3.   for(let i = 0; i < arr.length; i++) {
  4.       if(array.indexOf(arr[i]) === -1) {
  5.         array.push(arr[i]);
  6.     }
  7.   }
  8.   return array
  9. }
  11. function unique2(arr){
  12.     let array = [];
  13.   for(let i of arr){
  14.       if(array.indexOf(i) == -1) {
  15.         array.push(i);
  16.     }
  17.   }
  18.   return array
  19. }

遍历数组，通过indexOf循环，不存在添加到新的数组中

利用sort() 去重

  1. function unique(arr) {
  2.     arr = arr.sort();
  3.   let array = [arr[0]];
  4.   for(let i=1; i<arr.length; i++) {
  5.       if(arr[i] != arr[i-1]) {
  6.         array.push(arr[i]);
  7.     }
  8.   }
  9.   return array;
  10. }

通过sort对数组进行排序，然后比较for循环内当前数和前一个的区别，如果不同，添加到新的数组中

利用Map数据结构去重

  1. function unique(arr){
  2.     let map = new Map();
  3.   let array = new Array();
  4.   for(let i of arr) {
  5.       if(!map.has(i)){
  6.         map.set(i, true);
  7.       array.push(i);
  8.     }
  9.   }
  10. }

利用对象的属性不能相等去重

  1. function unique(arr){
  2.     let obj = {};
  3.   let array = [];
  4.   for(let i of arr){
  5.       if(!obj[i]){
  6.         array.push(i);
  7.       obj[i] =1;
  8.     } else {
  9.         obj[i]++; // 可以获取每个数重复了几次
  10.     }
  11.   }
  12.     return array;
  13. }

利用[…new Set(arr)]去重

  1. [...new Set(arr)]