Split array of objects with different properties names into an object and separate them by a given n-CodePudding

I have an array containing objects. Now I want to slice the array to a new object containing only those objects matching a certain property name and grouped by this property name. The thing is that I also have properties names that are different between them. The names and ID's repeat through the array of objects, but inside the new object, it should contain the ID and the name only once.

The original array looks like this:

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'
    }
];

The new object should look like this:

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' }
    ]
};

I appreciate the help.

As requested, I tried using reduce() and filter(), but I was not able to make them to split. Here is the code:

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);

About the strange data structure, I am getting those data from a database with a SELECT SQL syntax.

CodePudding user response：

Here you go, This can be enhance further

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);

CodePudding user response：

This is not a trivial algorithm. Here is a [mostly] functional implementation that handles an arbitrary number of ids and names

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)

CodePudding user response：

I probably went along a similar path as @Andrew did and, yes, I admit too, that this was not really trivial.

It might be a better idea to change your SQL selection in order to avoid receiving redundant data that makes these lengthy conversions necessary.

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);