Javascript实现数组去重方法及效率对比

tulayang 发布于2019-08-26 10:28 / 1185人阅读

摘要：前言其实网上搜索这些方法一堆堆的，之所以还来写一遍主要是因为自己习惯一种之后就忘了其他方法怎么实现，就写一写总结一下，顺便做个测试看看哪个效率最高，为了更好展示效果，我会先总结认为比较好的方法，后面统一测试。

前言

其实网上搜索这些方法一堆堆的，之所以还来写一遍主要是因为自己习惯一种之后就忘了其他方法怎么实现，就写一写总结一下，顺便做个测试看看哪个效率最高，为了更好展示效果，我会先总结认为比较好的方法，后面统一测试。（温馨提示：下文衹是为了简便，一般情况下不建议写在原型上，容易污染全局）

一，通过寻找对象属性

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun1(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

二，通过寻找数组位置

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun2(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

三，跟寻找数组位置类似，搜索数字第一次出现的位置是不是跟当前位置一样

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun3(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

四，比较常规，先排序，再比较前后两个数字是不是相等

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}
console.log(sortFun4(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

接下来是网上比较少的效率比较了，也是本文重点，我们先生成一个随机数组函数和计时函数统一比较
(温馨提示:随机数组执行一次之后就保存在一个变量,而每次执行函数花费时间都会有几毫秒偏差,你们想看多几种结果就狠狠地按按F5就好了,也只能这么搞..)

首先生成一个一千个数字的数组

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函数运行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(1000000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

本次函数运行花了：1毫秒
本次函数运行花了：1毫秒
本次函数运行花了：0毫秒
本次函数运行花了：1毫秒
（嗯，果然现代浏览器强大无比，不吐槽旧浏览器了）

看看十万个数字

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函数运行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(100000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

现在开始出现明显差距了
本次函数运行花了：65毫秒
本次函数运行花了：4毫秒
本次函数运行花了：4毫秒
本次函数运行花了：5毫秒

看看一百万个数字（数据庞大，开始吃不消了，等个五六秒吧）

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函数运行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(1000000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

本次函数运行花了：661毫秒
本次函数运行花了：24毫秒
本次函数运行花了：20毫秒
本次函数运行花了：27毫秒

总结

数据说话,

服务器托管混合云数组去重高效率 javascript数组方法 javascript实现方法 js 去重效率

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/106243.html

最全的数组去重方法对比

摘要：本文最早发布于，为原创常规方法两种数组深拷贝，为不了影响原来的数组第一种方法常用但是有坑碰到这种情况就出问题了第二种方法使用，方法返回的结果并不一定是升序，主要目的是将重复的数字排到一起使用的方法两种简洁优雅版奇技淫巧更新看到评论本文最早发布于csdn，为原创常规方法两种 let json = arr => { let res = [], obj = {};...

BlackHole1 2019-08-19 18:44 评论0 收藏0
跟underscore一起学数组去重

摘要：引子数组去重是一个老生常谈的话题，在面试中也经常会被问道。其中如果数组是排序的，去重运算效率更高，因为排序能够将相同的数排列在一起，方便前后比较。当数组有序对于对象的去重，我们知道为，所以使用比较对象在实际场景中没有意义。引子数组去重是一个老生常谈的话题，在面试中也经常会被问道。对于去重，有两种主流思想：先排序，线性遍历后去重，时间复杂度O(n*log2n)；使用哈希，空间换...

flybywind 2019-08-23 15:54 评论0 收藏0
JS中的数组去重方法总结

摘要：第一种常规法最直观的思路创建一个新数组如果新数组中已经包含了当前的第个元素，那么跳过否则把当前项到新数组中输出这种方法用到了方法。特殊情况当数组中既有数字又有字符串的时候，如此时希望和都保留，那么上述的方法无法达到要求。第一种：常规法（最直观的思路） function unique(arr){ var n = []; //创建一个新数组 for(var i = 0; ...

Aldous 2019-08-20 10:40 评论0 收藏0
JavaScript 实现数组更多的高阶函数

摘要：实现数组更多的高阶函数吾辈的博客原文场景虽说人人平等，但有些人更加平等。若是有一篇适合萌新阅读的自己实现数组更多操作的文章，情况或许会发生一些变化。类似于的初始值，但它是一个函数，避免初始值在所有分组中进行累加。 JavaScript 实现数组更多的高阶函数吾辈的博客原文: https://blog.rxliuli.com/p/fc... 场景虽说人人平等，但有些人更加平等。为...

aervon 2019-08-23 18:31 评论0 收藏0
JS程序

摘要：设计模式是以面向对象编程为基础的，的面向对象编程和传统的的面向对象编程有些差别，这让我一开始接触的时候感到十分痛苦，但是这只能靠自己慢慢积累慢慢思考。想继续了解设计模式必须要先搞懂面向对象编程，否则只会让你自己更痛苦。 JavaScript 中的构造函数学习总结。知识只有分享才有存在的意义。是时候替换你的 for 循环大法了~ 《小分享》JavaScript中数组的那些迭代方法~ ...

melody_lql 2019-08-22 11:22 评论0 收藏0