将具有不同属性名称的对象数组拆分为一个对象，并用给定的名称将它们分隔开

Question

我有一个包含对象的数组。现在，我想将数组切片为一个新对象，该对象只包含与某个属性名称匹配并按该属性名称分组的对象。问题是，我也有不同的属性名称。名称和ID在对象数组中重复，但在新对象内部，它应该只包含一次ID和名称。

原始数组如下所示：

let personArray = [
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl'
},
{
id_dentist: 2,
dentist_name: 'Lisa',
id_secretary: 9,
secretary_name: 'Beth',
id_security: 5,
security_name: 'Monica'
},
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl'
}
];

新对象应该是这样的：

let personObject = {
dentist: [
{ id_dentist: 1, dentist_name: 'John' },
{ id_dentist: 2, dentist_name: 'Lisa' },
],
secretary: [
{ id_secretary: 6, secretary_name: 'Paul' },
{ id_secretary: 9, secreatary_name: 'Beth' },
],
security: [
{ id_security: 3, security_name: 'Carl' },
{ id_security: 5, security_name: 'Monica' }
]
};

我很感激你的帮助。

根据要求，我尝试使用reduce()和filter()，但无法将它们拆分。这是代码：

const obj = personArray.reduce((acc, cur) => {
const key = Object.keys(cur).filter(f => /^id_/.test(f))[0].split('_')[1];
if (!acc[key]) acc[key] = [];
acc[key].push(cur);
return acc;
}, {});
console.log(obj);

关于奇怪的数据结构，我从一个使用SELECTSQL语法的数据库中获取这些数据。

Answer 1

给你，这可以进一步增强

let personArray = [{"id_dentist":1,"dentist_name":"John","id_secretary":6,"secretary_name":"Paul","id_security":3,"security_name":"Carl"},{"id_dentist":2,"dentist_name":"Lisa","id_secretary":9,"secretary_name":"Beth","id_security":5,"security_name":"Monica"},{"id_dentist":1,"dentist_name":"John","id_secretary":6,"secretary_name":"Paul","id_security":3,"security_name":"Carl"}];
const personObject = { dentist: [], secretary: [], security: [] };
const isExist = (arr, id, key) => arr.find(x => x[key] === id);

personArray.reduce((personObj, person) => {

const isDentistExists = isExist(personObj.dentist, person.id_dentist, 'id_dentist');

if (!isDentistExists) {
personObj.dentist.push({
id_dentist: person.id_dentist,
dentist_name: person.dentist_name
});
}

const isSecretaryExists = isExist(personObj.secretary, person.id_secretary, 'id_secretary');

if (!isSecretaryExists) {
personObj.secretary.push({
id_secretary: person.id_secretary,
secretary_name: person.secretary_name
});
}

const isSecurityExists = isExist(personObj.security, person.id_security, 'id_security');

if (!isSecurityExists) {
personObj.security.push({
id_security: person.id_security,
security_name: person.security_name
});
}

return personObj;
}, personObject);
console.log(personObject);

Answer 2

这不是一个简单的算法。这里有一个[主要]功能实现，它处理任意数量的id并命名

let personArray = [
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl',
},
{
id_dentist: 2,
dentist_name: 'Lisa',
id_secretary: 9,
secretary_name: 'Beth',
id_security: 5,
security_name: 'Monica',
},
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl',
},
]
const parsed = Object.fromEntries(
Object.keys(personArray[0])
.filter(key => key.startsWith('id_'))
.map(id => {
const uniqIds = [...new Set(personArray.map(person => person[id]))]
const [, name] = id.split('_')
const matchingPeople = uniqIds.map(uniqId => {
return personArray.find(person => uniqId === person[id])
})
return matchingPeople.map(person => ({
[id]: person[id],
[`${name}_name`]: person[`${name}_name`],
}))
})
.filter(entry => entry.length > 0)
.map(groupedPeople => {
const [name] = Object.keys(groupedPeople[0])
.find(key => key.includes('_name'))
.split('_')
return [name, groupedPeople]
})
)
console.log(parsed)

Answer 3

我可能和@Andrew走了一条类似的路，是的，我也承认，这并不是一件小事。

更改SQL选择可能是一个更好的主意，以避免接收到冗余数据，从而使这些冗长的转换成为必要。

const arr = [
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl'
},
{
id_dentist: 2,
dentist_name: 'Lisa',
id_secretary: 9,
secretary_name: 'Beth',
id_security: 5,
security_name: 'Monica'
},
{
id_dentist: 1,
dentist_name: 'John',
id_secretary: 6,
secretary_name: 'Paul',
id_security: 3,
security_name: 'Carl'
}
], types=Object.keys(arr[0]).reduce((a,c,k)=>{
k=c.match(/id_(.*)/);
if(k) a.push(k[1]);
return a;
},[]);
const res=Object.entries(arr.reduce((a,c)=>{
types.forEach((t,id)=>{
id="id_"+t;
a[t+":"+c[id]]={[id]:c[id],[t+"_name"]:c[t+"_name"]}
});
return a;
},{})).reduce((a,[k,o],n)=>{
[n]=k.split(":");
(a[n]=a[n]||[]).push(o)
return a;
},{});
console.log(res);