Question

我有一个名为allLeads的对象数组，它为数组中的每个项目存储一个leadName和leadId以及一个称为Leads的项目，这是另一个对象数组。

但是目前我如何从后端接收数据是Leads阵列一次只能存储一个对象。我想为每个leadId和leadName 合并此线索阵列。

目前如何

const allLeads = [
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "hello", url: "bye" }]
  },
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "lets", url: "go" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "dont", url: "try" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "other", url: "side" }]
  }
];

我希望它成为

const allLeads = [
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "hello", url: "bye" }, { profile: "lets", url: "go" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "dont", url: "try" }, { profile: "other", url: "side" }]
  }
];

Answer 1

const allLeads = [
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "hello", url: "bye" }]
  },
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "lets", url: "go" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "dont", url: "try" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "other", url: "side" }]
  }
];
function handle(array) {
  let obj = array.reduce((acc, cur) => {
    acc[cur.leadId] = acc[cur.leadId] || {};
    acc[cur.leadId].leads = acc[cur.leadId].leads || [];
    acc[cur.leadId].leadName = cur.leadName;
    acc[cur.leadId].leadId = cur.leadId;
    acc[cur.leadId].leads.push(...cur.leads);
    return acc;
  }, {});
  return Object.values(obj);
}
  console.log(handle(allLeads))

Answer 2

1。使用map()，new Set()

我们可以建立一个唯一的ID列表，然后为每个ID添加值。

const result = [...new Set(allLeads.map(x => x.leadId))].map(x => ({
  leadName: allLeads.find(y => y.leadId === x).leadName,
  leadId: x,
  leads: allLeads.filter(y => y.leadId === x).map(z => z.leads[0])
}));

  const allLeads = [
    {
      leadName: "software development",
      leadId: 123,
      leads: [{ profile: "hello", url: "bye" }]
    },
    {
      leadName: "software development",
      leadId: 123,
      leads: [{ profile: "lets", url: "go" }]
    },
    {
      leadName: "business development",
      leadId: 234,
      leads: [{ profile: "dont", url: "try" }]
    },
    {
      leadName: "business development",
      leadId: 234,
      leads: [{ profile: "other", url: "side" }]
    }
  ];
  
  const result = [...new Set(allLeads.map(x => x.leadId))].map(x => ({
    leadName: allLeads.find(y => y.leadId === x).leadName,
    leadId: x,
    leads: allLeads.filter(y => y.leadId === x).map(z => z.leads[0])
  }));
  
  console.log(result);

2。使用forEach()

对于每一项，请检查ID是否重复，并对它们进行不同的操作。

const reuslt = [];
allLeads.forEach(x => {
  const item = reuslt.find(y => y.leadId === x.leadId);
  item ? item.leads.push(x.leads[0]) : reuslt.push(x);
});

const allLeads = [
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "hello", url: "bye" }]
  },
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "lets", url: "go" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "dont", url: "try" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "other", url: "side" }]
  }
];

const reuslt = [];
allLeads.forEach(x => {
  const item = reuslt.find(y => y.leadId === x.leadId);
  item ? item.leads.push(x.leads[0]) : reuslt.push(x);
});

console.log(reuslt);

3。使用reduce()，Object.values()

构建一个对象，最后转移到结果数组。

const result = Object.values(allLeads.reduce((acc, cur) => {
  const item = acc[cur.leadId];
  item ? item.leads.push(cur.leads[0]) : acc = { ...acc, [cur.leadId]: cur};
  return acc;
}, {}));

const allLeads = [
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "hello", url: "bye" }]
  },
  {
    leadName: "software development",
    leadId: 123,
    leads: [{ profile: "lets", url: "go" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "dont", url: "try" }]
  },
  {
    leadName: "business development",
    leadId: 234,
    leads: [{ profile: "other", url: "side" }]
  }
];

const result = Object.values(allLeads.reduce((acc, cur) => {
  const item = acc[cur.leadId];
  item
    ? item.leads.push(cur.leads[0])
    : (acc = { ...acc, [cur.leadId]: cur });
  return acc;
}, {}));

console.log(result);

Answer 3

用键（作为唯一名称，这里我们需要ID +名称组合）和值来创建一个对象，以聚合线索元素。（如果密钥已经存在，只需将线索推入现有密钥即可）。
循环结束后，只需让他sort()来构建上述对象，即可将值作为数组获取。

Object.values

Answer 4

这不是一个花哨的解决方案，但可伸缩性却更高。创建一个新的阵列以将线索推入或更新现有的阵列。

merge = raw => {
    contains = (merged, leadName, leadId) => merged.leadName === leadName && leadId === merged.leadId;
    const merged = [];

    raw.forEach(lead => {
        const { leadName, leadId } = lead;
        const m = merged.find(mg => contains(mg, leadName, leadId));
        if (m) {
            m.leads.push(...lead.leads);
        } else {
            merged.push(lead);
        }
    });

    return merged;
};

请注意，如果LeadId是唯一的，则可以简单地修改contains方法以按ID进行匹配。

如何合并嵌套对象数组的内容？

4 个答案: