精华内容
下载资源
问答
  • 采用数组中的reduce方法,遍历数组,也是通过对象访问属性的方法 var arr = [{ key: '01', value: '乐乐' }, { key: '02', value: '博博' }, { key: '03', value: '淘淘' },{ key: '04', value: '哈哈' ...
  • js代码-数组 对象去重 (对象的所有属性相同才能认为相同)
  • 本文实例讲述了JS实现数组简单去重数组根据对象中的元素去重操作。分享给大家供大家参考,具体如下: js数组简单去重 var arr1 = [1, 2, 3, 4, 5, 6, 3, 4, 3]; function arrayUnique1(arr) { var result = [], ...
  • 本文实例讲述了JS数组对象去重操作。分享给大家供大家参考,具体如下: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>www.jb51.net js数组对象去重&...
  • 本文实例讲述了JS实现数组去重及数组对象去重功能。分享给大家供大家参考,具体如下: 大家在写项目的时候一定遇到过这种逻辑需求,就是给一个数组进行去重处理,还有一种就是给数组内的对象根据某一个属性,比如...
  • js代码-2个数组对象去重获取合并后的数组
  • 数组对象去重

    2020-08-14 14:40:41
    简单的数组去重 在开发过程中经常会遇到去重 首先简单的去重话无非就是一个数组里面有重复的数据 例如 let array = ["苹果","香蕉","西瓜","西瓜"]; let newarray = []; for(let i=0;i<array.length;i++){ if...

    简单的数组去重

    在开发过程中经常会遇到去重

    首先简单的去重话无非就是一个数组里面有重复的数据

    例如

    let array = ["苹果","香蕉","西瓜","西瓜"];
    
    let newarray = [];
    for(let i=0;i<array.length;i++){
      if(newarray.indexOf(array[i])==-1){
        newarray.push(array[i]);
      }
    }
    
    console.log(newarray);
    
    
    
    

    这样无非是利用数组方法indexOf()来判断数组中是否有这个元素,如果没有返回-1,我就把它push到新的空数组里面,这样就实现了简单的去重!

    数组对象去重

    var arr = [{
       id: '01',
       value: '乐乐'
      }, {
       id: '02',
       value: '博博'
      }, {
       id: '03',
       value: '淘淘'
      },{
       id: '04',
       value: '哈哈'
      },{
       id: '01',
       value: '乐乐'
      }];
      
       var result = [];
      var obj = {};
      for (var i = 0; i < arr.length; i++) {
        if (!obj[arr[i].id]) {
          result.push(arr[i]);
          obj[arr[i].id] = true;
        }
      }
      console.log(result);
    

    这样做就去重了,其实也是和上面那个方法差不多 只是数组中的对象不支持用indexOf(),所以利用空对象当中间件

    每次判断空对象是否有这个key值,如果没有则,往空数组里面push这个对象,每push完之后把已经push过去的这个id记录一下,这样就实现了数组对象去重

    展开全文
  • 1. 数组去重 let arr = [1, 3, 5, 6, 9, 1, 3, 2]; new Set(arr) // 去重 Array.from(new Set(arr)) // ...2. 数组对象去重 方法一: let arr = [{ key: 'R', code: 520 }, { key: 'o', code: 521 }, { key

    1. 数组去重

    let arr = [1, 3, 5, 6, 9, 1, 3, 2];
    
    new Set(arr)  // 去重
    Array.from(new Set(arr))  // 将伪数组转换成真数组 并去重
    

    2. 数组对象去重

    方法一:
    
    let arr = [{
            key: 'R',
            code: 520
          },
          {
            key: 'o',
            code: 521
          },
          {
            key: 'y',
            code: 522
          },
          {
            key: 'a',
            code: 666
          },
          {
            key: 'l',
            code: 668
          },
          {
            key: 'oo',
            code: 521
          }];
    const codeArr = []; // 通过code来判断重复项
    arr.forEach(v => codeArr.push(v.key));
    const newArr = []; // 去重后的新数组
    const newCode = new Set(keyArr);  // code去重
    newCode.forEach(item =>{
      const index = codeArr.findIndex(item2 => item2 === item);
      newArr.push(arr[index]);
    })
    console.log('去重后的数组:', newArr);
    
    方法二: 利用reduce
    let arr = [{
            key: 'R',
            code: 520
          },
          {
            key: 'o',
            code: 521
          },
          {
            key: 'y',
            code: 522
          },
          {
            key: 'a',
            code: 666
          },
          {
            key: 'l',
            code: 668
          },
          {
            key: 'oo',
            code: 521
          }];
    const hash = {};
    const newArray = arr.reduce((item, next)=>{
        hash[next.code] ? '' : hash[next.code] = true && item.push(next);
        return item;
      },[])
    console.info('去重后的数组:', newArray);
    
    展开全文
  • JS数组对象去重

    2021-10-09 11:06:58
    开发调试中遇到这种数据,需求是去掉多余重复的数据,很明显是数组对象去重,怎么办呢?开整 2.普通数组去重 先来讲一下普通数组去重吧 const arr = [1,2,2,2,3,1]; const newArr = new Set(arr); console.log...

    目录

    1.问题发现:

    2.普通数组去重

    3.数组对象去重

    (1)冒泡排序

    (2)利用对象访问属性的方法,判断对象中是否存在key

    (3)利用reduce


    1.问题发现:

     开发调试中遇到这种数据,需求是去掉多余重复的数据,很明显是数组对象去重,怎么办呢?开整

    2.普通数组去重

    先来讲一下普通数组去重吧

    const arr = [1,2,2,2,3,1];
    const newArr = new Set(arr);
    console.log(newArr); //[1,2,3]

    3.数组对象去重

    开始这次的重点

    (1)冒泡排序

    var arr = [{name: 'a',id: 1}, {name: 'a',id: 2}, {name: 'b',id: 3}, {name: 'c',id: 4},
     {name: 'c',id: 5}, {name: 'b',id: 6}, {name: 'd',id: 7}];
    function deWeight() {
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[i].name == arr[j].name) {
                    arr.splice(j, 1);
                    //因为数组长度减小1,所以直接 j++ 会漏掉一个元素,所以要 j--
                    j--;
                }
            }
        }
        return arr;
    }
    
    

    如果业务需求后面重复的是覆盖之前的值,就将arr.splice(j, 1)改成arr.splice(i, 1)

    (2)利用对象访问属性的方法,判断对象中是否存在key

        //利用对象访问属性的方法,判断对象中是否存在key
        let result = [];
        let arr = [
     
        { id: 1, name: "张三", age: 15 },
     
        { id: 4, name: "John", age: 18 },
     
        { id: 2, name: "李四", age: 18 },
     
        { id: 1, name: "张三", age: 15 },
         
        { id: 5, name: "Jack", age: 18 },
     
        { id: 3, name: "王五", age: 10 },
     
        { id: 5, name: "Jack", age: 18 },
     
        { id: 4, name: "John", age: 18 },
     
        { id: 5, name: "Jack", age: 18 }
     
        ];
     
        var obj = {};
        for(var i =0; i<arr.length; i++){
           if(!obj[arr[i].id]){
              result.push(arr[i]);
              obj[arr[i].id] = true;
           }
        }
        

    (3)利用reduce

       let arr = [
     
        { id: 1, name: "张三", age: 15 },
     
        { id: 4, name: "John", age: 18 },
     
        { id: 2, name: "李四", age: 18 },
     
        { id: 1, name: "张三", age: 15 },
         
        { id: 5, name: "Jack", age: 18 },
     
        { id: 3, name: "王五", age: 10 },
     
        { id: 5, name: "Jack", age: 18 },
     
        { id: 4, name: "John", age: 18 },
     
        { id: 5, name: "Jack", age: 18 }
     
        ];
    let obj= {};
     
    arr= arr.reduce((preVal, curVal) => {
     
    if (!obj[curVal.id]) {
              obj[curVal.id] = true;
              preVal.push(curVal);
    }
     
    return preVal
     
    }, []) // 请注意,必须标记是数组的默认值

    暂时只想到这些方法了

    展开全文
  • 今天要写的是数组对象去重的方式,先看看数组对象的形式 let arrObj = [ { name: "小红", id: 1 }, { name: "小橙", id: 1 }, { name: "小黄", id: 4 }, { name: "小绿", id: 3 }, { name: "小青", id: 1 }, ...

    哈喽哈喽,我又来了。

    今天分享的是数组对象去重的方式,先看看数组对象的形式:

    let arrObj = [
        { name: "小红", id: 1 },
        { name: "小橙", id: 1 },
        { name: "小黄", id: 4 },
        { name: "小绿", id: 3 },
        { name: "小青", id: 1 },
        { name: "小蓝", id: 4 }
    ];

    下面是我想要得到的结果,就是把id的值一样的对象删掉

    方法一:双层for循环

    两两比较,如果后一个对象的id值和前一个对象的id值相等,就把后面的对象删除

    let arrObj = [
        { name: "小红", id: 1 },
        { name: "小橙", id: 1 },
        { name: "小黄", id: 4 },
        { name: "小绿", id: 3 },
        { name: "小青", id: 1 },
        { name: "小蓝", id: 4 }
    ];
    function fn1(tempArr) {
        for (let i = 0; i < tempArr.length; i++) {
            for (let j = i + 1; j < tempArr.length; j++) {
                if (tempArr[i].id == tempArr[j].id) {
                    tempArr.splice(j, 1);
                    j--;
                };
            };
        };
        return tempArr;
    };
    console.log(fn1(arrObj));

     方法二:indexOf()

    定义一个数组存储id的值,然后逐个比较,把id值重复的对象删除即可

    let arrObj = [
        { name: "小红", id: 1 },
        { name: "小橙", id: 1 },
        { name: "小黄", id: 4 },
        { name: "小绿", id: 3 },
        { name: "小青", id: 1 },
        { name: "小蓝", id: 4 }
    ];
    function fn2(tempArr) {
        let newArr = [];
        for (let i = 0; i < tempArr.length; i++) {
            if (newArr.indexOf(tempArr[i].id) == -1) {
                newArr.push(tempArr[i].id);
            } else {
                tempArr.splice(i, 1);
            };
        };
        return tempArr;
    };
    console.log(fn2(arrObj));

    方法三:对象访问属性的方法

    采用对象访问属性的方法,判断属性值是否存在

    let arrObj = [
        { name: "小红", id: 1 },
        { name: "小橙", id: 1 },
        { name: "小黄", id: 4 },
        { name: "小绿", id: 3 },
        { name: "小青", id: 1 },
        { name: "小蓝", id: 4 }
    ];
    function fn3(tempArr) {
        let result = [];
        let obj = {};
        for (let i = 0; i < tempArr.length; i++) {
            if (!obj[tempArr[i].id]) {
                result.push(tempArr[i]);
                obj[tempArr[i].id] = true;
            };
        };
        return result;
    };
    console.log(fn3(arrObj));

    方法四:Map()

    has方法可以判断Map对象中是否存在指定元素,有则返回true,否则返回false

    set方法可以向Map对象添加新元素 map.set(key, value)

    values方法可以返回Map对象值的遍历器对象

    let arrObj = [
        { name: "小红", id: 1 },
        { name: "小橙", id: 1 },
        { name: "小黄", id: 4 },
        { name: "小绿", id: 3 },
        { name: "小青", id: 1 },
        { name: "小蓝", id: 4 }
    ];
    let map = new Map();
    for (let item of arrObj) {
        if (!map.has(item.id)) {
            map.set(item.id, item);
        };
    };
    arr = [...map.values()];
    console.log(arr);

    以上四种方式,可以根据自己的喜好选择,如有错误,欢迎斧正。

    展开全文
  • 问题:数组对象去重 方法一:es5冒泡排序法,去重arr(较好用) var arr = [{name: 'a',id: 1}, {name: 'a',id: 2}, {name: 'b',id: 3}, {name: 'c',id: 4}, {name: 'c',id: 6}, {name: 'b',id: 6}, {name: 'd...
  • 主要介绍了vue中对象数组去重的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 常见普通数组去重 利用Es6 Set去重 unique(arr){ return Array.from(new Set(arr)) }, 利用filter unique(arr){ return arr.filter((item,index,arr)=>{ return arr.indexOf(item,0) === index; }); ...
  • 数组对象去重并拿到重复的次数@TOC 网上数组对象去重方法可见,很多发了一下错误的拿到重复次数的方法。本人亲测有效的数组对象去重并可以拿到重复的次数。 直接上代码 let points = [{ lat: 22.687, lng: 114....
  • vue中实现数组对象去重 <el-button type="primary" size="medium" @click="quChong()">点击</el-button> quChong() { let arr = [ { id: 1, name: '111' }, { id: 1, name: '111' }, { id:...
  • findIndex() 查找元素,返回值是该元素的数组下标 ...// 数组对象去重 var arr = [{ id: 1, name: 'ceshi', type: '01', price: '33', }, { id: 2, name: 'ceshi', type: '02', price: '33'
  • js数组对象去重

    2020-09-25 10:03:00
    数组对象去重 最近项目中遇到一个数组对象去重的的问题,情景是数组对象中的每一个对象key 是相同的,但是key的数量不固定,研究了一下 ,想到了下面这种写法 // 数组对象去重 let mappingList = [ {id:1,name:'...
  • 数组对象: var str = [ {name: "张三",id: 1}, {name: "李四",id: 2}, {name: "王五",id: 3}, {name: "小明",id: 2}, {name: "小红",id: 1}, ]; 1、双层for循环 for(var i=0;i<str.length - 1;i++){...
  • //首先声明一个数组 var arr = [{ name: '张三', id: 1, integral: 10 }, { name: '李四', id: 2, integral: 20 }, { name: '王五', id: 3, integral: 30
  • ,点击加入购物车时,会将这件商品的数据对象加入到一个数组里,这时就需要对这个数组进行去重了,不然购物车页面里渲染出的数据会有重复的。这个数组类似于这种: let arr = [ {id:1,name:1}, {id:2,name:2}, {id:3...
  • 数组对象去重 题目: // 输入 [false, true, 1, 2, '1', '2', {}, {}, NaN, NaN, undefined, null].uniq(); // 获得 [false, true, 1, 2, '1', '2', {}, {}, NaN, undefined, null] 解决方法: 方法1: Array....
  • let arr = [ { name: "tom", sex: "male", age: "16", }, { name: "tom", sex: "male", age: "16", }, { name: "tina", sex: "female", age: "15", }, { name: "tina", sex: "female", ... {...
  • 我是BiKaBi,今天遇到一个这样的问题,需要取到数组中最后更新的数组,先来个实例 var arr = [ { eId: 3, answer: 30 }, { eId: 4, answer: 40 }, { eId: 3, answer: 10 }, { eId: 3, answer: 80 }, { eId: 5, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,541
精华内容 16,616
关键字:

数组对象去重