关于数组筛选重复的元素

Question

例如：

 var arrt = [
        {name:'华为',type:'p30'},
        {name:'华为',type:'p20'},
        {name:'华为',type:'mate20'},
        {name:'苹果',type:'iphoneX'},
        {name:'三星',type:'s10'},
        {name:'三星',type:'note10'}
      ];

怎么把name相等的对象进添加一个index,能表明该对象在数组中name相同的元素中的位置，
得到数组

arrt = [
        {name:'华为',type:'p30',index:0},
        {name:'华为',type:'p20',index:1},
        {name:'华为',type:'mate20',index:2},
        {name:'苹果',type:'iphoneX',index:0},
        {name:'三星',type:'s10',index:0},
        {name:'三星',type:'note10',index:1}
      ];

请问有什么好的解决方法

Answer 1

不用考虑数组顺序

目前能想到的最简方法

var arrt = [
    { name: "华为", type: "p30" },
    { name: "华为", type: "p20" },
    { name: "华为", type: "mate20" },
    { name: "苹果", type: "iphoneX" },
    { name: "三星", type: "s10" },
    { name: "三星", type: "note10" }
];
let obj = {};
console.log(
    arrt.reduce((result, cur) => {
        result.push({
            ...cur,
            index: (obj[cur.name] = obj[cur.name] === undefined ? 0 : obj[cur.name] + 1) && obj[cur.name]
        });
        return result;
    }, [])
);

@美凌格丶 补充回答

let arrt = [
    { belong: ["手机", "华为", "p系"], type: "p30" },
    { belong: ["手机", "华为"], type: "mate20" },
    { belong: ["手机", "三星"], type: "s10" },
    { belong: ["手机", "华为", "荣耀"], type: "荣耀10" },
    { belong: ["手机", "华为", "荣耀"], type: "荣耀8" },
    { belong: ["手机", "华为"], type: "mate10" },
    { belong: ["手机", "华为", "p系"], type: "p20" },
    { belong: ["手机", "三星"], type: "note10" },
    { belong: ["手机2", "华为", "荣耀"], type: "荣耀v10" },
    { belong: ["手机2", "华为", "荣耀"], type: "荣耀v8" }
];
let obj = {};
let result = arrt.reduce((result, cur) => {
    let key = cur.belong.sort((a, b) => a - b).toString();
    let isSubArr = Object.keys(obj).some(item => {
        return item.indexOf(key) >= 0 && item !== key;
    });
    let buff = Object.keys(obj).filter(item => item.indexOf(key) >= 0);
    let len = buff.length + buff.reduce((total, cur) => total + obj[cur], 0);
    result.push({
        ...cur,
        index: (obj[key] = obj[key] === undefined ? (isSubArr ? 1 : 0) : obj[key] + 1) && (buff.length !== len && buff[0] !== key ? len - 1 : len)
    });
    return result;
}, []);
console.log(result);

Answer 2

@luozz 如果数据格式为

 arrt:[{ belong: ['手机','华为','p系'], type: "p30" },
      { belong: ['手机','华为'], type: "mate20" },
      { belong: ['手机','华为'], type: "mate10" },
      { belong: ['手机',"三星"], type: "s10" },
      { belong: ['手机','华为','荣耀'], type: "荣耀10" },
      { belong: ['手机','华为','荣耀'], type: "荣耀8" },
      { belong: ['手机','华为','p系'], type: "p20" },
      { belong: ['手机',"三星"], type: "note10" },
      { belong: ['手机2','华为','荣耀'], type: "荣耀v10" },
      { belong: ['手机2','华为','荣耀'], type: "荣耀v8" }],

怎么处理能处理成

arrt:[{ belong: ['手机','华为','p系'], type: "p30",index:0 },
              { belong: ['手机','华为'], type: "mate20" ,index:1},
              { belong: ['手机','华为'], type: "mate10",index:2 },
              { belong: ['手机',"三星"], type: "s10" ,index:0},
              { belong: ['手机','华为','荣耀'], type: "荣耀10" ,index:0},
              { belong: ['手机','华为','荣耀'], type: "荣耀8" ,index:1},
              { belong: ['手机','华为','p系'], type: "p20",index:1 },
              { belong: ['手机',"三星"], type: "note10",index:1 },
              { belong: ['手机2','华为','荣耀'], type: "荣耀v10",index:0 },
              { belong: ['手机2','华为','荣耀'], type: "荣耀v8",index:1 }],

（p30属于p系，也属于华为，p20同样，这两个排序就是0,1，荣耀10，荣耀8同样如此，但mate20属于华为，p30也属于华为，但在mate20前面，所以mate20的索引从1开始,这样以此类推），求大神能不能告知有什么解决方法吗

@luozz 回答如下：

let arrt = [
    { belong: ["手机", "华为", "p系"], type: "p30" },
    { belong: ["手机", "华为"], type: "mate20" },
    { belong: ["手机", "华为"], type: "mate10" },
    { belong: ["手机", "三星"], type: "s10" },
    { belong: ["手机", "华为", "荣耀"], type: "荣耀10" },
    { belong: ["手机", "华为", "荣耀"], type: "荣耀8" },
    { belong: ["手机", "华为", "p系"], type: "p20" },
    { belong: ["手机", "三星"], type: "note10" },
    { belong: ["手机2", "华为", "荣耀"], type: "荣耀v10" },
    { belong: ["手机2", "华为", "荣耀"], type: "荣耀v8" }
];
let obj = {};
let result = arrt.reduce((result, cur) => {
    let key = cur.belong.sort((a, b) => a - b).toString();
    let isSubArr = Object.keys(obj).some(item => {
        return item.indexOf(key) >= 0 && item !== key;
    });
    result.push({
        ...cur,
        index: (obj[key] = obj[key] === undefined ? (isSubArr ? 1 : 0) : obj[key] + 1) && obj[key]
    });
    return result;
}, []);
console.log(result);

Answer 3

var arrt = [
  {name:'华为',type:'p30'},
  {name:'华为',type:'p20'},
  {name:'华为',type:'mate20'},
  {name:'苹果',type:'iphoneX'},
  {name:'三星',type:'s10'},
  {name:'三星',type:'note10'}
];

// 先根据name分组,并增加index
var obj = {};
arrt.forEach(item => {
  if(obj[item.name]){
    obj[item.name].push({...item, index: obj[item.name].length})
  }else{
    obj[item.name] = [{...item, index: 0}]
  }
})

// 组合起来
let result = [];
Object.keys(obj).forEach(key => {
  result = result.concat(obj[key])
})


console.log(result)

这样吧

Answer 4

function handler(arr, key) {
  let obj = {},
    i = 0,
    len = arr.length

  for (; i < len; i++) {
    let value = arr[i],
      property = obj.hasOwnProperty(value[key])

    if (!property) {
      obj[value[key]] = 0
      arr[i].index = 0
    } else {
      obj[value[key]] += 1
      arr[i].index = obj[value[key]]
    }
  }
  return arr
}

Answer 5

//首先进行数组排序,保证相同name的对象在数组内是连续的,如果能保证,可不进行排序
arrt.sort((a, b) => a.name > b.name)

//添加index
arrt.reduce((before, item, index) => {
    item.index = before.name == item.name ? before.index + 1 : 0
    return item
},{});