精华内容
下载资源
问答
  • JS去重的几种方法

    千次阅读 2021-02-20 20:42:43
    1、利用set去重 代码如下(示例): function arr1(arr) { return Array.from(new Set(arr)) } var arr = [1, 1, 1, 2, 2, 3, 4, 5, 6, 3, 4, 2, 4, 1,]; console.log(arr1(arr)) 这是目前最简单的去重方法,但是不...

    1、利用set去重

    代码如下(示例):

    function arr1(arr) {
                    return Array.from(new Set(arr))
                }
                var arr = [1, 1, 1, 2, 2, 3, 4, 5, 6, 3, 4, 2, 4, 1,];
                console.log(arr1(arr))
    

    这是目前最简单的去重方法,但是不支持对象方法,如果是复杂数据格式建议用以下几种。

    2、

    新建一个空数组arr,遍历原先的数组,若遍历的值不在arr中,将值传入该数组。

    代码如下(示例):

    function arr1(array) {
                    var arr = []; //一个新的数组存放去重后的结果
                    for (var i = 0; i < array.length; i++) {
                        if (arr.indexOf(array[i]) == -1) { //indexof()方法判断在数组中的位置,若不存在,返回-1
                            arr.push(array[i]);
                        }
                    }
                    return arr;
                }
                var Array = [1, 2, 2, 3];
                console.log(arr1(Array));// [1, 2, 3]
    

    3.

    使用两层for循环嵌套,再用splice()方法删除。
    代码如下(示例):

    function clear(arr){            
            for(var i=0; i<arr.length; i++){
                for(var j=i+1; j<arr.length; j++){
                    if(arr[i]==arr[j]){         //第一个等同于第二个,splice方法删除第二个
                        arr.splice(j,1);
                        j--;
                    }
                }
            }
    return arr;
    }
    var arr = [1,2,2,3];
        console.log(clear(arr));
    

    4.

    先用sort()方法进行排序,再对排序后的结果进行相邻比对。

     function arr1(arr) {
                        if (!Array.isArray(arr)) {
                            console.log('type error!')
                            return;
                        }
                        arr = arr.sort()
                        var arrry = [arr[0]];
                        for (var i = 1; i < arr.length; i++) {
                            if (arr[i] !== arr[i - 1]) {
                                arrry.push(arr[i]);
                            }
                        }
                        return arrry;
                    }
                    var arr = [1, 2, 2, 3];
                    console.log(arr1(arr));
    

    5.利用includes

    function arr1(arr) {
                            if (!Array.isArray(arr)) {
                                console.log('type error!')
                                return
                            }
                            var array = [];
                            for (var i = 0; i < arr.length; i++) {
                                if (!array.includes(arr[i])) {//includes 检测数组是否有某个值
                                    array.push(arr[i]);
                                }
                            }
                            return array
                        }
                        var arr = [1, 1,2,3];
                        console.log(arr1(arr))
    

    6.使用hasOwnProperty

    function arr1(arr) {
                        var obj = {};
                        return arr.filter(function (item, index, arr) {
                            return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
                        })
                    }
                    var arr= [1, 2, 2, 3];
                    console.log(arr1(arr));
    

    7.使用filter

    function arr1(arr) {
                        return arr.filter(function (item, index, arr) {
                            //当前元素,在原始数组中的第一个索引==当前索引值,否则返回当前元素
                            return arr.indexOf(item, 0) === index;
                        });
                    }
                    var arr = [1, 2, 2, 3];
                    console.log(arr1(arr))
    

    8.使用递归去重

    function arr1(arr) {
                        var array = arr;
                        var len = array.length;
    
                        array.sort(function (a, b) {   //排序后更加方便去重
                            return a - b;
                        })
    
                        function loop(index) {
                            if (index >= 1) {
                                if (array[index] === array[index - 1]) {
                                    array.splice(index, 1);
                                }
                                loop(index - 1);    //递归loop,然后数组去重
                            }
                        }
                        loop(len - 1);
                        return array;
                    }
                    var arr = [1, 2, 2, 3,3];
                    console.log(arr1(arr))
    

    9.使用Map数据结构去重

    function arr1(arr) {
                        let map = new Map();
                        let array = new Array();  // 数组用于返回结果
                        for (let i = 0; i < arr.length; i++) {
                            if (map.has(arr[i])) {  // 如果有该key值
                                map.set(arr[i], true);
                            } else {
                                map.set(arr[i], false); // 如果没有该key值
                                array.push(arr[i]);
                            }
                        }
                        return array;
                    }
                    var arr = [1,2,2,3,3,4];
                    console.log(arr1(arr))
    
    展开全文
  • 本篇文章主要介绍了详解JS去重及字符串奇数位小写转大写 ,非常具有实用价值,需要的朋友可以参考下。
  • js去重的方法

    2019-09-23 20:45:32
    一、简单数组去重(IE8以下不支持数组的indexOf()方法) function isDuplicate(arr) { var temp = [] //临时数组 for (var i = 0; i < arr.length; i++) { if (temp.indexOf(arr[i]) == -1) { temp.push(arr...

    一、简单数组去重(IE8以下不支持数组的indexOf()方法)

    function isDuplicate(arr) {
      var temp = []   //临时数组
      for (var i = 0; i < arr.length; i++) {
        if (temp.indexOf(arr[i]) == -1) {
          temp.push(arr[i])
        }
      }
      return temp
    };
    
    var array = [12, 87, 45, 12, 9, 8, 3, 9];
    console.log(isDuplicate(array));  //[12, 87, 45, 9, 8, 3]
    
    

    二、数组键值对去重

    var arr = [{
      key: '01',
      value: '王元宝'
    }, {
      key: '02',
      value: '吴富贵'
    }, {
      key: '01',
      value: '王元宝'
    }, {
      key: '04',
      value: '吴富贵'
    }];
    // 方法1:利用对象访问属性的方法,判断对象中是否存在key
    var result = [], obj = {};
    for (var i = 0; i < arr.length; i++) {
      if (!obj[arr[i].key]) {
        result.push(arr[i])
        obj[arr[i].key] = true
      }
    }
    console.log(result); // [ {key: "01", value: "王元宝"}, {key: "02", value: "吴富贵"}, {key: "04", value: "吴富贵"}]
    
    

    三、利用reduce方法遍历数组,reduce第一个参数是遍历需要执行的函数,第二个参数是item的初始值

    
    var arr = [{
      key: '01',
      value: '王元宝'
    }, {
      key: '02',
      value: '吴富贵'
    }, {
      key: '01',
      value: '王元宝'
    }, {
      key: '04',
      value: '吴富贵'
    }];
    var obj = {};
    arr = arr.reduce(function (item, next) {
      obj[next.key] ? '' : obj[next.key] = true && item.push(next)
      return item
    }, []);
    console.log(arr);  // [ {key: "01", value: "王元宝"}, {key: "02", value: "吴富贵"}, {key: "04", value: "吴富贵"}]
    

    四、利用js的filter方法

    var arr = [5, 6, 8, 8, 6, 8, 6];
    var newArr = arr.filter((items, index, arry) => { //按照条件过滤,返回满足条件的新数组
      return arry.indexOf(items) === index //过滤掉下标相同的值
    });
    console.log(newArr) // [5, 6, 8]
    

    五、利用 ES6的set 方法

    function isDuplicate(arr) {
      //Set数据结构,类似于数组,值都是唯一的
      return Array.from(new Set(arr)) // 利用Array.from将Set结构转换成数组
    };
    
    var arr = [5, 6, 8, 8, 6, 8, 6];
    console.log(isDuplicate(arr));// [5, 6, 8]
    
    
    [...new Set(array)] 也可以粗暴直接使用
    
    展开全文
  • JavaScript去重

    2020-05-14 21:13:54
    Array.from(new Set(arr))或[...new Set(arr)]: var arr = [1,1,2,5,6,3,5,5,6,8,9,8];...for循环嵌套,利用splice去重: function unique (origin) { let arr = [].concat(origin); for (let i = 0; i

    Array.from(new Set(arr))[...new Set(arr)]:

    var arr = [1,1,2,5,6,3,5,5,6,8,9,8];
    console.log(Array.from(new Set(arr)))
    // console.log([...new Set(arr)])
    

    for循环嵌套,利用splice去重

    function unique (origin) {
      let arr = [].concat(origin);
      for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
          if (arr[i] == arr[j]) {
            arr.splice(j, 1);
            j--;
          }
        }
      }
      return arr;
    }
    var arr = [1,1,2,5,6,3,5,5,6,8,9,8];
    console.log(unique(arr))
    

    新建数组,利用includes去重:

    function unique (arr) {
      let res = []
      for (let i = 0; i < arr.length; i++) {
        if (!res.includes(arr[i])) {
          res.push(arr[i])
        }
      }
      return res;
    }
    var arr = [1,1,2,5,6,3,5,5,6,8,9,8];
    console.log(unique(arr))
    

    先用sort排序,然后用一个指针从第0位开始,配合while循环去重

    function unique (arr) {
      arr = arr.sort(); // 排序之后的数组
      let pointer = 0;
      while (arr[pointer]) {
        if (arr[pointer] != arr[pointer + 1]) { // 若这一项和下一项不相等则指针往下移
          pointer++;
        } else { // 否则删除下一项
          arr.splice(pointer + 1, 1);
        }
      }
      return arr;
    }
    var arr = [1,1,2,5,6,3,5,5,6,8,9,8];
    console.log(unique(arr))
    

    待补充

    展开全文
  • JS去重方法

    千次阅读 2018-07-24 09:39:02
    方法三:利用对象的属性不能相同的特点进行去重 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ...

    方法一:

    双层循环,外层循环元素,内层循环时比较值

    如果有相同的值则跳过,不相同则push进数组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    Array.prototype.distinct = function(){

     var arr = this,

      result = [],

      i,

      j,

      len = arr.length;

     for(i = 0; i < len; i++){

      for(j = i + 1; j < len; j++){

       if(arr[i] === arr[j]){

        j = ++i;

       }

      }

      result.push(arr[i]);

     }

     return result;

    }

    var arra = [1,2,3,4,4,1,1,2,1,1,1];

    arra.distinct();    //返回[3,4,2,1]

    方法二:利用splice直接在原数组进行操作

    双层循环,外层循环元素,内层循环时比较值

    值相同时,则删去这个值

    注意点:删除元素之后,需要将数组的长度也减1.

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    Array.prototype.distinct = function (){

     var arr = this,

      i,

      j,

      len = arr.length;

     for(i = 0; i < len; i++){

      for(j = i + 1; j < len; j++){

       if(arr[i] == arr[j]){

        arr.splice(j,1);

        len--;

        j--;

       }

      }

     }

     return arr;

    };

    var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];

    var b = a.distinct();

    console.log(b.toString()); //1,2,3,4,5,6,56

    优点:简单易懂

    缺点:占用内存高,速度慢

    方法三:利用对象的属性不能相同的特点进行去重

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    Array.prototype.distinct = function (){

     var arr = this,

      i,

      obj = {},

      result = [],

      len = arr.length;

     for(i = 0; i< arr.length; i++){

      if(!obj[arr[i]]){ //如果能查找到,证明数组元素重复了

       obj[arr[i]] = 1;

       result.push(arr[i]);

      }

     }

     return result;

    };

    var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];

    var b = a.distinct();

    console.log(b.toString()); //1,2,3,4,5,6,56

    方法四:数组递归去重

    运用递归的思想

    先排序,然后从最后开始比较,遇到相同,则删除

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    Array.prototype.distinct = function (){

     var arr = this,

      len = arr.length;

     arr.sort(function(a,b){  //对数组进行排序才能方便比较

      return a - b;

     })

     function loop(index){

      if(index >= 1){

       if(arr[index] === arr[index-1]){

        arr.splice(index,1);

       }

       loop(index - 1); //递归loop函数进行去重

      }

     }

     loop(len-1);

     return arr;

    };

    var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];

    var b = a.distinct();

    console.log(b.toString());  //1,2,3,4,5,6,45,56

    方法五:利用indexOf以及forEach

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    Array.prototype.distinct = function (){

     var arr = this,

      result = [],

      len = arr.length;

     arr.forEach(function(v, i ,arr){  //这里利用map,filter方法也可以实现

      var bool = arr.indexOf(v,i+1);  //从传入参数的下一个索引值开始寻找是否存在重复

      if(bool === -1){

       result.push(v);

      }

     })

     return result;

    };

    var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];

    var b = a.distinct();

    console.log(b.toString()); //1,23,2,3

    方法六:利用ES6的set

    Set数据结构,它类似于数组,其成员的值都是唯一的。

    利用Array.from将Set结构转换成数组

    ?

    1

    2

    3

    4

    function dedupe(array){

     return Array.from(new Set(array));

    }

    dedupe([1,1,2,3]) //[1,2,3]

    拓展运算符(...)内部使用for...of循环

    ?

    1

    2

    3

    let arr = [1,2,3,3];

    let resultarr = [...new Set(arr)];

    console.log(resultarr); //[1,2,3]

    下面给大家补充介绍合并数组并去重的方法

    一、concat()方法

    思路:concat() 方法将传入的数组或非数组值与原数组合并,组成一个新的数组并返回。该方法会产生一个新的数组。

    ?

    1

    2

    3

    4

    5

    function concatArr(arr1, arr2){

      var arr = arr1.concat(arr2);

      arr = unique1(arr);//再引用上面的任意一个去重方法

      return arr;

    }

    二、Array.prototype.push.apply()

    思路:该方法优点是不会产生一个新的数组。

    ?

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    var a = [1, 2, 3];

    var b = [4, 5, 6];

    Array.prototype.push.apply(a, b);//a=[1,2,3,4,5,6]

    //等效于:a.push.apply(a, b);

    //也等效于[].push.apply(a, b);

    function concatArray(arr1,arr2){

      Array.prototype.push.apply(arr1, arr2);

      arr1 = unique1(arr1);

      return arr1;

    }

    展开全文
  • 1.数组去重 var arr = ["1343", "rere", "1343", "rerd"]; Array.prototype.unique = function(){ var res = []; var json = {}; for(var i = 0; i < this.length;i++){ if(!json[this[i]]){ ...
  • 有时候我们做项目的时候往往会需要把数组里面一些重复的项去掉,但是原生JS有排序,有筛选等等,但是就是没有数组去重怎么办呢? 这能怎么办,自己手动实现嘛。 数组不像对象和hash有唯一的标志特征(key)。所以,...
  • 先看代码,复制使用即可,在实际开发中,我们经常会遇到数组去重的问题,简单的数组比如[1,2,3,1] 可以很轻松的使用es6New set或者别的形式,稍微复杂点的对很多刚入门的小伙伴是个不错的考验,基于此,将以下较好的...
  • JS去重ES6方法

    2019-09-21 01:20:14
    // JS去重ES6方法 let arr = [0,0,0,1,1,2,3,5,9,6,5,4,10]; // 数组去重法1 let newarr = []; //定义一个空数组 for (var i = 0;i < arr.length;i++) { //先遍历 if(newarr.indexOf(arr[i]) == -1){ //...
  • js去重方法

    2017-05-20 09:28:00
    方法三:这是一种原生JavaScript去重方法,借助一个空数组来实现去重,便于理解底层原理(xyz函数带有参数) 方法四:同上(xyz函数不带参数)拓展:需要注意的一点就是此函数可以传多个数组,但是要看...
  • js去重

    2019-09-26 17:59:02
    let temp = []; for (var a = 0; a < this.resultList.length; a++) { if (temp.indexOf(this.resultList[a].attributes.NAME) === -1) { temp.push(this...
  • 原生JS数组去重方法总结(5种)超干货! 正式开始前让俺絮叨几句 很久很久之前总结的东西,在电脑上放着,直到前两天电脑分个盘分炸了重装系统,之前耗费时间总结的各种知识类别都丢了,感觉整个世界都暗了很烦躁。...
  • 数组去重:使用ES6的数据类型 Set Set的存储结构与数组类似,Set中不允许 存放重复数据 声明一个重复的数组,中有重复的数据 var arr = [111,444,333,111,222,333,444] 使用Set var newArr = new Set(arr); 输出的...
  • 废话不多话,直接看代码 let taskDocNumArr =[{id:1,name:z},{id:1,name:z},{id:2,name:k}] ... hash[curVal.id] //这里的id用作去重的唯一标识 ? "" : (hash[curVal.id] = true && preVal.push(curV
  • 对多维数组,对象,进行去重,相同的值只保留一个,常见的new Set()和filter,只能去重一维数组,并不能进行深层的去重,逻辑:判断是否为对象,为对象判断是否为数组或是真的对象,递归一直筛选为值,判断首次...
  • js去重的几种方法

    2020-09-15 20:20:29
    1. arr.includes(item) => arr数组里面是否包含item这个元素,返回...利用对象的key是唯一性的特点也可以去重 let arr = [1,2,3,3,2,1] let obj = {} arr.forEach(ee=>{ obj[ee] = '' }) console.log(Object.keys(obj))
  • JavaScript去重的方法

    2020-12-10 16:41:28
    //去重方法一: var arr = [1, 2, 2, 2, 5, 55, 4, 55, 2, 32]; for(var i = 0;i < arr.length;i++){ for(var j = i + 1;j < arr.length:j++){ //将重复的,删除后面的元素 if(arr[i] === arr[j]){ //...
  • js去重算法

    2020-10-14 16:05:09
    方法一 Set //set中没有重复的元素 Arr = [1, 2, 3, '3', 3, 6, 7, 9, 8, 12, 8] ...方法2 先排序,再去重 //适用于数组中都是number类型 //若有'3',无法成功去重 Arr = [1, 2, 3, 3, 6, 7, 9, 8, 12, 8] function uni
  • JS去重的四种方法

    千次阅读 2019-08-21 14:33:30
    编写函数norepeat(arr) 将数组的重复元素去掉,并返回新的数组 方法一 function norepeat(arr){ for(var i = 0;i<arr.length-1;i++){ for(var j = i+1;j<arr.length;... if(arr[i]==arr[j]){ ...
  • 方法一: 采用对象访问属性的方法,判断属性值是否存在,如果不存在就添加。 方法二: 采用数组中的reduce方法,遍历数组,也是通过对象访问属性的方法 var arr = [{ key: '01', value: '乐乐' ...
  • 方法1:ES6新特性Set Array.prototype.rmSome = function() { return Array.from(new Set(this)); } 方法2:利用对象名唯一 Array.prototype.rmSome = function() { let tempObj = {} this...
  • js去重获取随机数

    2017-04-19 16:43:00
    if(arr.indexOf(num) == -1){//去重,如果数组里面不存在生成的随机数 arr.push(num)//添加到数组里面 } if(arr.length == sum){//如果随机数满足我们需要的长度 break;//停止循环 } } console.log(arr);/...
  • js对字符串(逗号隔开的)进行去重操作;js对json数组进行去重操作(指定某个属性),开发中经常遇到的前端小方法,简单实用
  • 本文实例讲述了JS实现的Object数组去重功能。分享给大家供大家参考,具体如下: 目标:实现成员为 Object 的数组的去重。 注意,这里的数组成员为 Object,而不是数值或者字符串。 调用方法: arr = distinct_arr_...
  • js去重的两种方法

    2017-08-29 16:22:00
    去重 去重方法和思路也很多,这里就介绍两种吧。 方法一: 1 2 3 4 5 6 7 8 9 10 11 function unique1(arr) { var res = [], len = arr.length; for (var i = 0; i < len; ...
  • 1:去重 参数:data为数组里面多个对象 目的:data中方有多种类型题目并且多个,需要去重后,每个题目只需要重复的获取一个就可以 //题目去重 let peons = data.reduce((cur,next) =>{ obj[next.typeName] ? ''...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,437
精华内容 16,174
关键字:

js去重