Tengo una matriz que contiene objetos. Ahora quiero dividir la matriz en un nuevo objeto que contenga solo aquellos objetos que coincidan con un determinado nombre de propiedad y agrupados por este nombre de propiedad. La cosa es que también tengo nombres de propiedades que son diferentes entre ellos. Los nombres y los ID se repiten en la matriz de objetos, pero dentro del nuevo objeto, debe contener el ID y el nombre solo una vez.
La matriz original se ve así:
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' } ];El nuevo objeto debería verse así:
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' } ] };Agradezco la ayuda.
Según lo solicitado, intenté usar reduce() y filter() , pero no pude hacer que se dividieran. Aquí está el código:
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); Acerca de la extraña estructura de datos, obtengo esos datos de una base de datos con una sintaxis SELECT SQL.
Aquí tienes, esto se puede mejorar aún más
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);Este no es un algoritmo trivial. Aquí hay una implementación [principalmente] funcional que maneja un número arbitrario de identificaciones y nombres
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)Probablemente seguí un camino similar al de @Andrew y, sí, también lo admito, que esto no fue realmente trivial.
Podría ser una mejor idea cambiar su selección de SQL para evitar recibir datos redundantes que hacen que estas largas conversiones sean necesarias.
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);