精华内容
下载资源
问答
  • 主要介绍了JS实现数组去重及数组内对象去重功能,结合实例形式分析了ES5与ES6两种版本针对数组去重的相关操作技巧,需要的朋友可以参考下
  • js实现数组去重

    2017-12-25 09:38:30
    js实现数组去重
    [...new Set([1, "1", 2, 1, 1, 3])]
     
    

    3、数组去重

    注:暂不考虑对象字面量,函数等引用类型的去重,也不考虑 NaNundefinednull等特殊类型情况。

    数组样本:[1, 1, '1', '2', 1]

    3.1 普通版

    无需思考,我们可以得到 O(n^2) 复杂度的解法。定义一个变量数组 res 保存结果,遍历需要去重的数组,如果该元素已经存在在 res 中了,则说明是重复的元素,如果没有,则放入 res 中。

    var a = [1, 1, '1', '2', 1]
    function unique(arr) {
        var res = []
        for (var i = 0, len = arr.length; i < len; i++) {
            var item = arr[i]
            for (var j = 0, len = res.length; j < jlen; j++) {
                if (item === res[j]) //arr数组的item在res已经存在,就跳出循环
                    break
            }
            if (j === jlen) //循环完毕,arr数组的item在res找不到,就push到res数组中
                res.push(item)
        }
        return res
    }
    console.log(unique(a)) // [1, 2, "1"]

    优点: 没有任何兼容性问题,通俗易懂,没有任何理解成本
    缺点: 看起来比较臃肿比较繁琐,时间复杂度比较高O(n^2)

    3.2 进阶版

    var a =  [1, 1, '1', '2', 1]
    function unique(arr) {
        return arr.filter(function(ele,index,array){
            return array.indexOf(ele) === index//很巧妙,这样筛选一对一的,过滤掉重复的
        })
    }
    console.log(unique(a)) // [1, 2, "1"]

    优点:很简洁,思维也比较巧妙,直观易懂。
    缺点:不支持 IE9 以下的浏览器,时间复杂度还是O(n^2)

    3.3 时间复杂度为O(n)

    var a =  [1, 1, '1', '2', 1]
    function unique(arr) {
        var obj = {}
        return arr.filter(function(item, index, array){
            return obj.hasOwnProperty(typeof item + item) ? 
            false : 
            (obj[typeof item + item] = true)
        })
    }
    
    console.log(unique(a)) // [1, 2, "1"]

    优点:hasOwnProperty 是对象的属性(名称)存在性检查方法。对象的属性可以基于 Hash 表实现,因此对属性进行访问的时间复杂度可以达到O(1);
    filter 是数组迭代的方法,内部还是一个 for 循环,所以时间复杂度是 O(n)
    缺点:不兼容 IE9 以下浏览器,其实也好解决,把 filter 方法用 for 循环代替或者自己模拟一个 filter 方法。

    3.4 终极版

    以 Set 为例,ES6 提供了新的数据结构 Set。它类似于数组,但是成员的值都是唯一的,没有重复的值。

    const unique = a => [...new Set(a)]

    优点:ES6 语法,简洁高效,我们可以看到,去重方法从原始的 14 行代码到 ES6 的 1 行代码,其实也说明了 JavaScript 这门语言在不停的进步,相信以后的开发也会越来越高效。
    缺点:兼容性问题,现代浏览器才支持,有 babel 这些都不是问题。

    你可能不知道的前端知识点:ES6 新的数据结构 Set 去重

    原文:https://github.com/jawil/blog/issues/24
    展开全文
  • JS实现数组去重

    2020-10-25 14:56:18
    JS实现数组去重(重复的元素只保留一个) 1.遍历数组法 它是最简单的数组去重方法(indexOf方法) 实现思路:新建一个数组,遍历去要重的数组,当值不在新数组的时候(indexOf为-1)就加入该新数组中; var arr=[2,8...

    JS实现数组去重(重复的元素只保留一个)

    1.遍历数组法

    它是最简单的数组去重方法(indexOf方法)
    实现思路:新建一个数组,遍历去要重的数组,当值不在新数组的时候(indexOf为-1)就加入该新数组中;

    var arr=[2,8,5,0,5,2,6,7,2];
    function unique1(arr){
      var hash=[];
      for (var i = 0; i < arr.length; i++) {
         if(hash.indexOf(arr[i])==-1){
          hash.push(arr[i]);
         }
      }
      return hash;
    }
    

    2.数组下标判断法

    调用indexOf方法,性能和方法1差不多
    实现思路:如果当前数组的第 i 项在当前数组中第一次出现的位置不是 i,那么表示第 i 项是重复的,忽略掉。否则存入结果数组。

    function unique2(arr){
      var hash=[];
      for (var i = 0; i < arr.length; i++) {
         if(arr.indexOf(arr[i])==i){
          hash.push(arr[i]);
         }
      }
      return hash;
    }
    

    3.排序后相邻去除法

    实现思路:给传入的数组排序,排序后相同的值会相邻,然后遍历排序后数组时,新数组只加入不与前一值重复的值。

    function unique3(arr){
      arr.sort();
      var hash=[arr[0]];
      for (var i = 1; i < arr.length; i++) {
         if(arr[i]!=hash[hash.length-1]){
          hash.push(arr[i]);
         }
      }
      return hash;
    }
    

    4.优化遍历数组法(推荐)

    实现思路:双层循环,外循环表示从0到arr.length,内循环表示从i+1到arr.length
    将没重复的右边值放入新数组。(检测到有重复值时终止当前循环同时进入外层循环的下一轮判断)

    function unique4(arr){
      var hash=[];
      for (var i = 0; i < arr.length; i++) {
        for (var j = i+1; j < arr.length; j++) {
          if(arr[i]===arr[j]){
            ++i;
          }
        }
          hash.push(arr[i]);
      }
      return hash;
    }
    

    5.ES6实现

    基本思路:ES6提供了新的数据结构Set。它类似于数组,但是成员的值都是唯一的,没有重复的值。
    Set函数可以接受一个数组(或类似数组的对象)作为参数,用来初始化。

    function unique5(arr){
      var x = new Set(arr);
     return [...x];
    }
    

    扩展:如果重复,则去掉该元素

    6.数组下标去重

    function unique22(arr){
      var hash=[];
      for (var i = 0; i < arr.length; i++) {
         if(arr.indexOf(arr[i])==arr.lastIndexOf(arr[i])){
          hash.push(arr[i]);
         }
      }
      return hash;
    })
    
    展开全文
  • 主要为大家详细介绍了javascript实现数组去重的多种方法,感兴趣的小伙伴们可以参考一下
  • JavaScript 实现数组去重 演示Demo 数组去重 // 方法一 function unique1(a) { var res = []; for (var i = 0, len = a.length; i < len; i++) { for (var j = i + 1; j < len; j++) { // 这一步十分巧...

    JavaScript 实现数组去重

    演示Demo 数组去重

    // 方法一
    function unique1(a) {
        var res = [];
        for (var i = 0, len = a.length; i < len; i++) {
            for (var j = i + 1; j < len; j++) {
                // 这一步十分巧妙
                // 如果发现相同元素
                // 则 i 自增进入下一个循环比较
                if (a[i] === a[j])
                    j = ++i;
            }
            res.push(a[i]);
        }
        return res;
    }
    var a = [1, 1, '1', '2', 1];
    console.log('去重前: ' + a);
    var ans = unique1(a);
    console.log('去重后: ' + ans); // => ["1", "2", 1]
    
    // 方法二
    function unique2(a) {
        var res = [];
        for (var i = 0, len = a.length; i < len; i++) {
            var item = a[i];
            for (var j = 0, jLen = res.length; j < jLen; j++) {
                if (res[j] === item)
                    break;
            }
            if (j === jLen)
                res.push(item);
        }
        return res;
    }
    var a = [1, 1, '1', '2', 1];
    console.log('去重前: ' + a);
    var ans = unique2(a);
    console.log('去重后: ' + ans); // => [1, "1", "2"]
    
    // 方法三
    function unique3(names) {
        var uniqueNames = [];
        $.each(names, function(i, el) {
            if ($.inArray(el, uniqueNames) === -1)
                uniqueNames.push(el);
        });
        return uniqueNames;
    }
    var names = ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Nancy", "Carl"];
    console.log('去重前: ' + names);
    var uniqueNames = unique3(names);
    console.log('去重后: ' + uniqueNames);

    参考资料

    转载于:https://www.cnblogs.com/hglibin/p/9928981.html

    展开全文
  • JavaScript实现数组去重

    2020-03-16 23:20:30
    JavaScript实现数组去重的两种方法: 1.简单粗暴直接循环将元素放到另一个新的空数组中,每次遍历如果新数组中不包含这个元素就放入到新数组中。 function unique1(arr) { const res = []; arr.forEach(item =>...

    两种方法:

    1.简单粗暴直接循环将元素放到另一个新的空数组中,每次遍历如果新数组中不包含这个元素就放入到新数组中。

    function unique1(arr) {
      const res = [];
      arr.forEach(item => {
        if (res.indexOf(item) < 0) {
          res.push(item);
        }
      });
      return res;
    }
    

    2.使用ES6中的Set。
    这个Set就是“集合”的意思,在数学上,“集合”有无序、不重等的特点,所以,正好符合咱们的需求啦!

    function uniqueArray2(arr) {
      const set = new Set(arr);
      return [...set];
    }
    

    测试走起~~:

    const arr = [1, 2, 3, 2, 1, 4];
    console.log(arr); // [ 1, 2, 3, 2, 1, 4 ]
    console.log(uniqueArray1(arr)); // [ 1, 2, 3, 4 ]
    console.log(uniqueArray2(arr)); // [ 1, 2, 3, 4 ]
    

    分析一下:
    从性能方面考虑的话,自然是第二种方法好多啦,代码简洁明了,省事儿多了!第一种方法中有两次遍历,还是比较耗费时间的,性能自然有点打折扣的。。
    完美收工!O(∩_∩)O哈哈~

    展开全文
  • 本文主要介绍了js实现数组去重方法及效率對比。具有很好的参考价值,下面跟着小编一起来看下吧
  • 给大家总结下JS实现数组去重方法(六种方法),面试中也经常会遇到这个问题。文中给大家引申的还有合并数组并去重的方法,感兴趣的朋友跟随脚本之家小编一起学习吧
  • 数组去重是一个比较常见的算法考察点,实现去重的方式无非就是唯一性或者非唯一性,简而言之,就是选出唯一的或者去掉不唯一的,下面总结了几种方法。 方法一:利用双层for循环通过原数组去重,就是遍历数组,把数组...
  • 主要介绍了JS实现数组去重,显示重复元素及个数的方法,涉及javascript数组遍历、统计、计算等相关操作技巧,需要的朋友可以参考下
  • js实现数组去重 <script> function quChong (arr){ // 定义一个去重函数 var newArr = []; // 定义一个新数组存放去重后的函数 for (var i = 0; i < arr.length; i++){...
  • javascript实现数组去重

    2018-11-22 14:35:00
    我最常用的两种方法 第一种:优化遍历数组法 1 //调用 2 var cidAttr=uniq(cid); 3 4 //数组去重 5 function uniq(array){ 6 var temp = []; 7 var index = [...
  • JS实现数组去重方法

    2018-10-10 16:50:00
    <!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>JS实现数组去重方法<...// 写出一个javascript的函数,实现对一个数组去重的功能// a.构建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,508
精华内容 12,203
关键字:

js实现数组去重