JavaScript: Identify similarities in values within an array of objects

Question

JavaScript: Identify similarities in values within an array of objects

In my Javascript code, I have an array of objects structured like this:

    var arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'author': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
    ];

My task is to create a list of all individuals (editors, authors & agents) mentioned in each object along with their respective roles. The desired output should include a new key/value-pair ('involved') formatted as follows:

'involved': 'Andrew (editor)|| Maria (editor)|| Dorian (author) || Gabi (author) || Bob (agent) || Peter (agent)'

The modified array of objects should look like this:

   var arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter', 'involved': 'Andrew (editor)|| Maria (editor)|| Dorian (author) || Gabi (author) || Bob (agent) || Peter (agent)'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto','involved': 'Dorian (editor, agent) || Guybrush (editor) || Peter (author) || Frodo (author) || Otto (author)'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter','involved': 'Klaus (editor) || Otmar (editor) || Jordan (author, agent) || Morgan (author) || Peter (agent)'},
    ];

If an individual plays multiple roles (e.g. in id 2 -> Dorian appears as both editor and agent), their name should only appear once in 'involved' but with all roles listed in brackets (e.g. Dorian (editor, agent))

As a beginner in programming, I am unsure how to approach this problem effectively. I believe the first step is to split all values by "||" into arrays and then compare each name with every other name in the array.

I would greatly appreciate any guidance or assistance on this issue.

javascript arrays object string-comparison

Answer 1

Answer №1

To achieve the desired outcome, it is essential to gather all names along with their corresponding job types and then present a grouped summary of this information.

 const
     collectNamesWithJobs = obj => {
         const
             jobTypes = ['editor', 'author', 'agent'],
             namesByJobType = jobTypes.reduce((result, key) => {
                 (obj[key + 's'] || '').split('||').forEach(value => (result[value] ??= []).push(key));
                 return result;
             }, {});

         return Object.entries(namesByJobType).map(([name, jobs]) => `${name} (${jobs.join(', ')})`).join(' || ')
     },
     dataCollection = [{ id: 1, editors: 'Andrew||Maria', authors: 'Dorian||Gabi', agents: 'Bob||Peter' }, { id: 2, editors: 'Dorian||Guybrush', author: 'Peter||Frodo', agents: 'Dorian||Otto' }, { id: 3, editors: 'Klaus||Otmar', authors: 'Jordan||Morgan', agents: 'Jordan||Peter' }],
     finalResult = dataCollection.map(obj => ({ ...obj, involvement: collectNamesWithJobs(obj) }));

console.log(finalResult);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

To achieve the desired outcome, it is essential to gather all names along with their corresponding job types and then present a grouped summary of this information.

 const
     collectNamesWithJobs = obj => {
         const
             jobTypes = ['editor', 'author', 'agent'],
             namesByJobType = jobTypes.reduce((result, key) => {
                 (obj[key + 's'] || '').split('||').forEach(value => (result[value] ??= []).push(key));
                 return result;
             }, {});

         return Object.entries(namesByJobType).map(([name, jobs]) => `${name} (${jobs.join(', ')})`).join(' || ')
     },
     dataCollection = [{ id: 1, editors: 'Andrew||Maria', authors: 'Dorian||Gabi', agents: 'Bob||Peter' }, { id: 2, editors: 'Dorian||Guybrush', author: 'Peter||Frodo', agents: 'Dorian||Otto' }, { id: 3, editors: 'Klaus||Otmar', authors: 'Jordan||Morgan', agents: 'Jordan||Peter' }],
     finalResult = dataCollection.map(obj => ({ ...obj, involvement: collectNamesWithJobs(obj) }));

console.log(finalResult);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

Answer №2

Transform the array by destructuring each object to extract a roles object without the id key.
Build a new map object that associates each person with an array of their roles.
Iterate over each key in the roles object and split it at || to obtain an array of names.
Iterate through the names and update the map object. If the name is not already added, include it using the ||= assignment operator.
Trim the last character of each role using slice to convert plural forms to singular (e.g., from "agents" to "agent").

The updated map object now contains each person as a key mapped to an array of roles.

{
  Dorian: ["editor", "agent"],
  Guybrush: ["editor"],
  Peter: ["author"],
  Frodo: ["author"],
  Otto: ["agent"]
}

Loop through the entries of the object to construct the involved string.
Return a new object with an additional key for involved.

const arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
];
    
const output = arrobj.map(({ id, ...roles }) => {
  const map = {}
  
  for (const r in roles) {
    const names = roles[r].split("||")
    for (const name of names) {
      map[name] ||= []
      map[name].push(r.slice(0,-1))
    }
  }
  
  const involved = Object.entries(map)
                         .map(([name, values]) => `${name} (${values.join(", ")})`)
                         .join(" || ")
                         
   return { id, ...roles, involved }
})

console.log(output)

Answer 4

Transform the array by destructuring each object to extract a roles object without the id key.
Build a new map object that associates each person with an array of their roles.
Iterate over each key in the roles object and split it at || to obtain an array of names.
Iterate through the names and update the map object. If the name is not already added, include it using the ||= assignment operator.
Trim the last character of each role using slice to convert plural forms to singular (e.g., from "agents" to "agent").

The updated map object now contains each person as a key mapped to an array of roles.

{
  Dorian: ["editor", "agent"],
  Guybrush: ["editor"],
  Peter: ["author"],
  Frodo: ["author"],
  Otto: ["agent"]
}

Loop through the entries of the object to construct the involved string.
Return a new object with an additional key for involved.

const arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
];
    
const output = arrobj.map(({ id, ...roles }) => {
  const map = {}
  
  for (const r in roles) {
    const names = roles[r].split("||")
    for (const name of names) {
      map[name] ||= []
      map[name].push(r.slice(0,-1))
    }
  }
  
  const involved = Object.entries(map)
                         .map(([name, values]) => `${name} (${values.join(", ")})`)
                         .join(" || ")
                         
   return { id, ...roles, involved }
})

console.log(output)

Answer 5

Answer №3

In this instance, a solution (ES5) is presented with potential areas for optimization. The main concept involves aggregating all editors into an array and then checking if authors and agents already exist within the composed array.

var arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
    ];
    
function getInvolved(arr) {
  return arr.map(function(el) {
    var editors = el.editors.split('||');
    var authors = el.authors.split('||');
    var agents = el.agents.split('||'); 
    var involved = editors.map(function(editor) {
      return editor += ' (editor)';
    });
    
    authors.forEach(function(author) { 
      if(editors.indexOf(author) === -1) {
        involved.push(author + ' (author)');
      } else {
        involved = involved.map(function(inv) {
          if(inv.indexOf(author) > -1) {
            inv += '(author)';
          }
          return inv;
        });
      }
    });
    
    agents.forEach(function(agent) { 
      if(editors.indexOf(agent) === -1 && authors.indexOf(agent) === -1) {
        involved.push(agent + ' (agent)');
      } else {
        involved = involved.map(function(inv) {
          if(inv.indexOf(agent) > -1) {
            inv += '(agent)';
          }
          return inv;
        });
      }
    });
    el.involved = involved.join('||'); 
    return el;
  });
}

console.log(getInvolved(arrobj));

Answer 6

In this instance, a solution (ES5) is presented with potential areas for optimization. The main concept involves aggregating all editors into an array and then checking if authors and agents already exist within the composed array.

var arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
    ];
    
function getInvolved(arr) {
  return arr.map(function(el) {
    var editors = el.editors.split('||');
    var authors = el.authors.split('||');
    var agents = el.agents.split('||'); 
    var involved = editors.map(function(editor) {
      return editor += ' (editor)';
    });
    
    authors.forEach(function(author) { 
      if(editors.indexOf(author) === -1) {
        involved.push(author + ' (author)');
      } else {
        involved = involved.map(function(inv) {
          if(inv.indexOf(author) > -1) {
            inv += '(author)';
          }
          return inv;
        });
      }
    });
    
    agents.forEach(function(agent) { 
      if(editors.indexOf(agent) === -1 && authors.indexOf(agent) === -1) {
        involved.push(agent + ' (agent)');
      } else {
        involved = involved.map(function(inv) {
          if(inv.indexOf(agent) > -1) {
            inv += '(agent)';
          }
          return inv;
        });
      }
    });
    el.involved = involved.join('||'); 
    return el;
  });
}

console.log(getInvolved(arrobj));

Answer 7

Answer №4

const arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
];

for (let obj of arrobj) {
  obj.involved = "";
  for (let key of Object.keys(obj)) {
    let strKey = [...key];
    strKey.pop();
    let role = strKey.join("");
    if (key === "involved") break;
    if (key !== "id") {
      obj.involved += obj[key]
        .split("||")
        .map((name) => name + "(" + role + ")||")
        .join("");
    }
    obj.involved = obj.involved.substr(0, obj.involved.length - 2).trim();
  }
}

console.log(arrobj);

Access the live demo here: https://repl.it/join/juljqzxt-theketan2

Answer 8

const arrobj = [
  {'id': 1, 'editors': 'Andrew||Maria', 'authors': 'Dorian||Gabi', 'agents': 'Bob||Peter'},
  {'id': 2, 'editors': 'Dorian||Guybrush', 'authors': 'Peter||Frodo', 'agents': 'Dorian||Otto'},
  {'id': 3, 'editors': 'Klaus||Otmar', 'authors': 'Jordan||Morgan', 'agents': 'Jordan||Peter'},
];

for (let obj of arrobj) {
  obj.involved = "";
  for (let key of Object.keys(obj)) {
    let strKey = [...key];
    strKey.pop();
    let role = strKey.join("");
    if (key === "involved") break;
    if (key !== "id") {
      obj.involved += obj[key]
        .split("||")
        .map((name) => name + "(" + role + ")||")
        .join("");
    }
    obj.involved = obj.involved.substr(0, obj.involved.length - 2).trim();
  }
}

console.log(arrobj);

Access the live demo here: https://repl.it/join/juljqzxt-theketan2

JavaScript: Identify similarities in values within an array of objects

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Reverse row changes in Angular Ag-Grid with the click of a button

Prevent background element from being selected with a double-click

Execute JavaScript code inside lightSlider

Converting an object to an array of values in TypeScript: A step-by-step guide

Tracking user engagement and traffic on a website with a single tracking ID for both screenviews and pageviews

Cease the toggling of series visibility and instead gray out the legend when clicked

Creating dynamic routes in React by pulling data from a JSON file

Navigate back to the previous page following the completion of an AJAX data submission

Error message: Unforeseen node express token problem

Receiving an ambiguous message from the meteor subscriptions

The Geocoder.geocode() method returns XML instead of JSON when invalid credentials are provided

Tips for controlling a "collapsed" state for every intricately nested node within a tree

Drawing graphics on an HTML5 Canvas with the power of React Native

import shaders from next.js

What is the best way to add distinct arrays into another array?

Changing the Speed of CSS3 Transitions Dynamically

Ways to interpret JSON in electron while receiving script from express server

Implementing defaultProps in conjunction with withStyles

retrieve an object with enum keys that are indexed

The functionality of HTML5 Drag and Drop upload is currently disabled on versions of Internet Explorer 10 and below