Tips on dividing or forming an array based on a duplicate key that repeats multiple times

Question

Tips on dividing or forming an array based on a duplicate key that repeats multiple times

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}]

To achieve the desired output where a new array is created on repeat of key "a," follow the format below:

[{a:1},{b:2},{c:3},{d:4}]
[{a:5},{b:6},{c:7}]
[{a:8},{c:9}]

javascript arrays multidimensional-array arraylist

Answer 1

Answer №1

For optimal performance, it is recommended not to modify the original source and avoid adding elements one by one. Instead, use the slice method:

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

let result = [], prev = 0, i = 0, [sc] = Object.keys(test[0]);
while(++i < test.length) sc in test[i] && result.push(test.slice(prev, prev = i));
result.push(test.slice(prev));

result.forEach(item => console.log(JSON.stringify(item)));

Here is a benchmark comparison:

` Chrome/125
-------------------------------------------------------
Alexander       ■ 1.00x | x10000000 570 579 608 626 627
Siva KV           1.93x |  x1000000 110 114 120 128 134
Roko C. Buljan    2.77x |  x1000000 158 159 166 169 170
------------------------------------------------------- `

Open in the playground

<script benchmark data-count="5000000">
const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

// @benchmark Roko C. Buljan
[...test].reduceRight((acc, ob, i, ref) => 
  (ob.hasOwnProperty("a") && acc.unshift(ref.splice(i)), acc)
, []);

// @benchmark Siva KV
{
const result = [];
let row = [];
test.forEach((item) => {
  const key = Object.keys(item)[0];
  if (key === "a") {
    if (row.length > 0) {
      result.push(row);
    }
    row = [item];
  } else {
    row.push(item);
  }
});
if (row.length > 0) {
  result.push(row);
}
result;
}

// @benchmark Alexander
let result = [], prev = 0, i = 0, sc = Object.keys(test[0])[0];
while(++i < test.length) sc in test[i] && result.push(test.slice(prev, prev = i));
result.push(test.slice(prev));
result;
</script>
<script src="https://cdn.jsdelivr.net/gh/silentmantra/benchmark/loader.js"></script>

Answer 2

For optimal performance, it is recommended not to modify the original source and avoid adding elements one by one. Instead, use the slice method:

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

let result = [], prev = 0, i = 0, [sc] = Object.keys(test[0]);
while(++i < test.length) sc in test[i] && result.push(test.slice(prev, prev = i));
result.push(test.slice(prev));

result.forEach(item => console.log(JSON.stringify(item)));

Here is a benchmark comparison:

` Chrome/125
-------------------------------------------------------
Alexander       ■ 1.00x | x10000000 570 579 608 626 627
Siva KV           1.93x |  x1000000 110 114 120 128 134
Roko C. Buljan    2.77x |  x1000000 158 159 166 169 170
------------------------------------------------------- `

Open in the playground

<script benchmark data-count="5000000">
const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

// @benchmark Roko C. Buljan
[...test].reduceRight((acc, ob, i, ref) => 
  (ob.hasOwnProperty("a") && acc.unshift(ref.splice(i)), acc)
, []);

// @benchmark Siva KV
{
const result = [];
let row = [];
test.forEach((item) => {
  const key = Object.keys(item)[0];
  if (key === "a") {
    if (row.length > 0) {
      result.push(row);
    }
    row = [item];
  } else {
    row.push(item);
  }
});
if (row.length > 0) {
  result.push(row);
}
result;
}

// @benchmark Alexander
let result = [], prev = 0, i = 0, sc = Object.keys(test[0])[0];
while(++i < test.length) sc in test[i] && result.push(test.slice(prev, prev = i));
result.push(test.slice(prev));
result;
</script>
<script src="https://cdn.jsdelivr.net/gh/silentmantra/benchmark/loader.js"></script>

Answer 3

Answer №2

If you're looking to experiment a bit, here's an example you can try out:

const sampleData = [
  { apple: 1 },
  { banana: 2 },
  { cherry: 3 },
  { date: 4 },
  { apple: 5 },
  { banana: 6 },
  { cherry: 7 },
  { apple: 8 },
  { cherry: 9 },
];

const organizeByFirstKey = (arr) => {
  const result = [];
  let row = [];
  arr.forEach((item) => {
    const key = Object.keys(item)[0];
    if (key === "apple") {
      if (row.length > 0) {
        result.push(row);
      }
      row = [item];
    } else {
      row.push(item);
    }
  });
  if (row.length > 0) {
    result.push(row);
  }
  return result;
};

console.log(organizeByFirstKey(sampleData));

Answer 4

If you're looking to experiment a bit, here's an example you can try out:

const sampleData = [
  { apple: 1 },
  { banana: 2 },
  { cherry: 3 },
  { date: 4 },
  { apple: 5 },
  { banana: 6 },
  { cherry: 7 },
  { apple: 8 },
  { cherry: 9 },
];

const organizeByFirstKey = (arr) => {
  const result = [];
  let row = [];
  arr.forEach((item) => {
    const key = Object.keys(item)[0];
    if (key === "apple") {
      if (row.length > 0) {
        result.push(row);
      }
      row = [item];
    } else {
      row.push(item);
    }
  });
  if (row.length > 0) {
    result.push(row);
  }
  return result;
};

console.log(organizeByFirstKey(sampleData));

Answer 5

Answer №3

It is important to keep track of the slice position index labeled as x. Slice the array starting from index x up to index i, and push those chunks into an Array named result:

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9];

const result = [], length = test.length - 1;
let x = 0, i = 0;
while (i<=length) (i++ === length || Object.hasOwn(test[i], "a")) && result.push(test.slice(x, x=i));

console.log(result);

Do note that Object.hasOwn() serves as a replacement for Object.prototype.hasOwnProperty(). It is advised to use Object.hasOwn() over the in operator. Using the in operator may offer a speed boost of 33%, but it can potentially yield incorrect results by returning true for inherited properties.

Alternatively, a slower example (~55% slower in performance) involves a backward approach utilizing Array.prototype.reduceRight(), Array.prototype.unshift(), and Array.prototype.splice()

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

const result = [...test].reduceRight((accumulator, obj, index, reference) =>
  (Object.hasOwn(obj, "a") && accumulator.unshift(reference.splice(index)), accumulator)
, []);

console.log(result);

The test array is initially shallow cloned using the Array Spread syntax [...test] and referenced as reference. During each reduceRight iteration, if

obj.hasOwnProperty("a") &&

condition matches, we add to the accumulator Array accumulator the contents of the reference clone from index index to the end. The splice operation modifies the reference array gradually reducing its size. Essentially, this process involves retrieving chunks of array data from reference and incorporating them into accumulator, which is then returned.

Answer 6

It is important to keep track of the slice position index labeled as x. Slice the array starting from index x up to index i, and push those chunks into an Array named result:

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9];

const result = [], length = test.length - 1;
let x = 0, i = 0;
while (i<=length) (i++ === length || Object.hasOwn(test[i], "a")) && result.push(test.slice(x, x=i));

console.log(result);

Do note that Object.hasOwn() serves as a replacement for Object.prototype.hasOwnProperty(). It is advised to use Object.hasOwn() over the in operator. Using the in operator may offer a speed boost of 33%, but it can potentially yield incorrect results by returning true for inherited properties.

Alternatively, a slower example (~55% slower in performance) involves a backward approach utilizing Array.prototype.reduceRight(), Array.prototype.unshift(), and Array.prototype.splice()

const test = [{a:1},{b:2},{c:3},{d:4},{a:5},{b:6},{c:7},{a:8},{c:9}];

const result = [...test].reduceRight((accumulator, obj, index, reference) =>
  (Object.hasOwn(obj, "a") && accumulator.unshift(reference.splice(index)), accumulator)
, []);

console.log(result);

The test array is initially shallow cloned using the Array Spread syntax [...test] and referenced as reference. During each reduceRight iteration, if

obj.hasOwnProperty("a") &&

condition matches, we add to the accumulator Array accumulator the contents of the reference clone from index index to the end. The splice operation modifies the reference array gradually reducing its size. Essentially, this process involves retrieving chunks of array data from reference and incorporating them into accumulator, which is then returned.

Answer 7

Answer №4

To accomplish this task, one can utilize the reduce function.

const data = [{x:1},{y:2},{z:3},{w:4},{x:5},{y:6},{z:7},{x:8},{z:9}];

const result = data.reduce((accumulated, item) => {
    if ('x' in item) {
        accumulated.push([]);
    }
    accumulated[accumulated.length - 1].push(item);
    return accumulated;
}, [[]]).filter(subarray => subarray.length > 0);

In this code snippet, the reduce function is employed to loop through the data array and group elements into subarrays. Whenever an object with the key "x" is found, a new empty subarray is appended to the result. Subsequently, items are inserted into the most recent subarray.

Ultimately, the generated subarrays are filtered to eliminate any empty ones, yielding the desired grouped arrays in the output.

Answer 8

To accomplish this task, one can utilize the reduce function.

const data = [{x:1},{y:2},{z:3},{w:4},{x:5},{y:6},{z:7},{x:8},{z:9}];

const result = data.reduce((accumulated, item) => {
    if ('x' in item) {
        accumulated.push([]);
    }
    accumulated[accumulated.length - 1].push(item);
    return accumulated;
}, [[]]).filter(subarray => subarray.length > 0);

In this code snippet, the reduce function is employed to loop through the data array and group elements into subarrays. Whenever an object with the key "x" is found, a new empty subarray is appended to the result. Subsequently, items are inserted into the most recent subarray.

Ultimately, the generated subarrays are filtered to eliminate any empty ones, yielding the desired grouped arrays in the output.

Tips on dividing or forming an array based on a duplicate key that repeats multiple times

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Prevent external scrolling while Bootstrap modal is active

Encountering issues when dynamically altering the material texture in three.js during runtime

Can someone advise me on how to ensure my function effectively delivers a desired outcome?

Identify the CSS class for the ionic component on the webpage

Locate a group of DOM selectors that correspond to the highlighted text

Transfer a variable from javascript/jquery to a PHP script within the same page

Explore our array of images displayed in an interactive gallery featuring clickable

Disable the resizing and responsiveness features in the jQuery Basic Slider

What is the solution to preventing Angular 1.3 ngMessages from affecting the size of my form?

Having trouble getting the CSS animation to work properly with the text

Issue with Jenkins running Cucumber causing timeout on JavaScript form

Exploring the Dynamic Connection: AngularJS and MongoDB

Sorting swiftly using pointers

setInterval versus delay

Choose all elements with a specific class name without the need to specify their position in the list

Is it wrong to use <match v-for='match in matches' v-bind:match='match'></match>? Am I allowed to incorporate the match variable from the v-for loop into the v-bind attribute on the

Different ways to activate the system bell in Node.js

Could implementing a click/keydown listener on each cell in a large React datagrid with thousands of cells impact performance?

Eliminate the prefixes of object keys in Node.js

Is there a way to modify the color of my question post-submission?