数组去重的性能比较

数组去重是面试常考点，但是这些方法的性能之间的比较，你知道吗？下面来比较一下

方法1：Array.filter()+indexOf()

 使用 ES6 中的 Array.filter() 遍历数组，并结合 indexOf 来排除重复项

let arr1 = Array.from(new Array(100000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct1(arr1, arr2).length); 
let end = new Date().getTime(); 
console.log('耗时', end - start); 

// 数组开始去重 
// distinct.js:11 去重后的长度 100000 
// distinct.js:14 耗时 9523 

// 方法1：Array.filter()+indexOf()
function distinct1(a, b) {
  // 数组去重
  let arr = a.concat(b);
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index;
  });
}

方法2：双重for循环

外层循环遍历元素，内层循环检查是否重复

当有重复值的时候，可以使用 push()，也可以使用 splice()

let arr1 = Array.from(new Array(100000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct2(arr1, arr2).length);

let end = new Date().getTime();
console.log('耗时', end - start);

// 方法2：双重for循环
// 外层循环遍历元素，内层循环检查是否重复
// 当有重复值的时候，可以使用 push()，也可以使用 splice()

function distinct2(a, b) {
  let arr = a.concat(b);
  for (let i = 0, len = arr.length; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      if (arr[i] === arr[j]) {
        arr.splice(j, 1);
        //   splice可以改变数组长度，所以数组长度len和j的下标减一
        len--;
        j--;
      }
    }
  }
  return arr;
}
// 数组开始去重
// 去重后的长度 100000
// 耗时 22534

方法3：双重for循环升级版

外层用 for...of 语句替换 for 循环，把内层循环改为 includes()

先创建一个空数组，当 includes() 返回 false 的时候，就将该元素 push 到空数组中

 类似的，还可以用 indexOf() 来替代 includes()

let arr1 = Array.from(new Array(100000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct3(arr1, arr2).length);

let end = new Date().getTime();
console.log('耗时', end - start);

// 方法3：双重for循环升级版
// 外层用 for...of 语句替换 for 循环，把内层循环改为 includes()
// 先创建一个空数组，当 includes() 返回 false 的时候，就将该元素 push 到空数组中
// 类似的，还可以用 indexOf() 来替代 includes()

function distinct3(a, b) {
  let arr = a.concat(b);
  let result = [];
  for (const i of arr) {
    //   如果result中没有i，就把i push进去数组result
    !result.includes(i) && result.push(i);
  }
  return result;
}

// 数组开始去重
// 去重后的长度 100000
// 耗时 9851

 这种方法和 filter + indexOf 挺类似

只是把 filter() 的内部逻辑用 for 循环实现出来，再把 indexOf 换为 includes

所以时长上也比较接近

方法4：Array.sort()

首先使用 sort() 将数组进行排序

然后比较相邻元素是否相等，从而排除重复项

let arr1 = Array.from(new Array(100000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct4(arr1, arr2).length);

let end = new Date().getTime();
console.log('耗时', end - start);

// 方法4：Array.sort()
// 首先使用 sort() 将数组进行排序
// 然后比较相邻元素是否相等，从而排除重复项
function distinct4(a, b) {
  let arr = a.concat(b);
  arr = arr.sort();
  let result = [arr[0]]; // result中保存排序后的数组的第一项
  for (let i = 0, len = arr.length; i < len; i++) {
    //   如果相邻两项元素不等，则push进去数组result
    arr[i] !== arr[i - 1] && result.push(arr[i]);
  }
  return result;
}
// 数组开始去重
// 去重后的长度 100001
// 耗时 95
// 这种方法只做了一次排序和一次循环，所以效率会比上面的方法都要高

方法5：new Set()

 ES6 新增了 Set 这一数据结构，类似于数组，但 Set 的成员具有唯一性

 基于这一特性，就非常适合用来做数组去重了

let arr1 = Array.from(new Array(100000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct5(arr1, arr2).length);

let end = new Date().getTime();
console.log('耗时', end - start);

// 方法5：new Set()
// ES6 新增了 Set 这一数据结构，类似于数组，但 Set 的成员具有唯一性
// 基于这一特性，就非常适合用来做数组去重了

function distinct5(a, b) {
  //   let arr = a.concat(b);
  return Array.from(new Set([...a, ...b]));
}
// 数组开始去重
// 去重后的长度 100000
// 耗时 37

// function distinct5(a, b) {
//   let arr = a.concat(b);
//   return Array.from(new Set(arr));
// }
// 数组开始去重
// 去重后的长度 100000
// 耗时 35

方法6：for...of + Object

首先创建一个空对象，然后用 for 循环遍历

利用对象的属性不会重复这一特性，校验数组元素是否重复

let arr1 = Array.from(new Array(1000000), (x, index) => {
  return index;
});
let arr2 = Array.from(new Array(50000), (x, index) => {
  return index + index;
});

let start = new Date().getTime();
console.log('数组开始去重');

console.log('去重后的长度', distinct6(arr1, arr2).length);

let end = new Date().getTime();
console.log('耗时', end - start);

// 方法6：for...of + Object
// 首先创建一个空对象，然后用 for 循环遍历
// 利用对象的属性不会重复这一特性，校验数组元素是否重复

function distinct6(a, b) {
  let arr = a.concat(b);
  let result = [];
  let obj = {};
  for (const i of arr) {
    if (!obj[i]) {
      result.push(i);
      obj[i] = 1;
    }
  }
  return result;
}

// 数组开始去重
// 去重后的长度 100000
// 耗时 27
// 速度非常快,ni new Set()还快

// 150w数据需要多长时间呢？
// 数组开始去重
// 去重后的长度 1000000
// 耗时 246  OMG，简直不敢相信

所以，性能比较好的方法，应该是

方法4：Array.sort()（好）

方法5：new Set()（较好）

方法6：for...of + Object（优）

 

本文参考：https://www.cnblogs.com/wisewrong/p/9642264.html 仅供学习