数组去重的性能比较

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

方法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 仅供学习