Benchmark: group-by - MeasureThat.net

Script Preparation code:

 var collection = [
    {
      name: 'Fabver',
      type: 1,
      company: 'ADL',
    },
    {
      name: 'Fabian',
      type: 0,
      company: 'ADL',
    },
    {
      name: 'Andrés',
      type: 0,
      company: 'JWT',
    },
    {
      name: 'Andrew',
      type: 1,
      company: 'JWT',
    },
  ];

var index = Math.floor(Math.random() * 3);
var key = ['name', 'type', 'company'][index]

Tests:

groupBy with two while
if (!collection.length) return [collection]; const origin = [...collection]; const groups = []; while (origin.length) { const group = []; const obj = origin.shift(); if (obj) { group.push(obj); let i = 0; while (i < origin.length) { if (obj[key] === origin[i][key]) { group.push(origin.splice(i, 1)[0]); } i++; } } groups.push(group); } return groups;
groupBy with while and filter
if (!collection.length) return [collection]; const groups = []; let i = 0; let selected = {}; while (i < collection.length) { if (!selected || selected[key] !== collection[i][key]) { selected = collection[i]; groups.push(collection.filter((item) => item[key] === selected[key])); } i++; } return groups;
groupBy with Set and filter
if (!collection.length) return [collection]; const groups = []; const keyValues = collection.map((item) => item[key]); const uniqueValues = [...new Set(keyValues)]; uniqueValues.forEach((value) => groups.push(collection.filter((item) => item[key] === value))); return groups;
groupBy with two filters
if (!collection.length) return [collection]; const groups = []; const keyValues = collection.map((item) => item[key]); const uniqueValues = keyValues.filter((value, index, self) => self.indexOf(value) === index); uniqueValues.forEach((value) => groups.push(collection.filter((item) => item[key] === value))); return groups;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
groupBy with two while
groupBy with while and filter
groupBy with Set and filter
groupBy with two filters

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Linux

View result in a separate tab

Test name	Executions per second
groupBy with two while	3933783.2 Ops/sec
groupBy with while and filter	2348533.0 Ops/sec
groupBy with Set and filter	563889.0 Ops/sec
groupBy with two filters	1463303.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test for grouping arrays by an object key. The benchmark is designed to measure the performance of different approaches for this task.

**Options being compared:**

1. **Two while loops**: This approach uses two nested while loops to group the array elements.
2. **While and filter**: This approach uses a single while loop and the `filter()` method to group the array elements.
3. **Set and filter**: This approach uses the `Set` data structure to get unique values from the array, and then filters the original array using these unique values.
4. **Two filters**: This approach uses two separate `filter()` methods to group the array elements.

**Pros and Cons:**

1. **Two while loops**:
	* Pros: Easy to understand and implement, can be optimized for specific use cases.
	* Cons: May lead to slower performance due to the nested loop structure.
2. **While and filter**:
	* Pros: More concise than two while loops, uses a built-in method (filter()) to simplify the code.
	* Cons: May have higher overhead due to function calls, and may not be optimized for specific use cases.
3. **Set and filter**:
	* Pros: Uses a modern data structure (Set) to get unique values, can lead to faster performance due to its caching mechanism.
	* Cons: Requires more memory to store the Set, and the `filter()` method has higher overhead.
4. **Two filters**:
	* Pros: Uses two separate methods, which can be optimized for specific use cases, and avoids the need for a Set data structure.
	* Cons: More verbose than other approaches, and may lead to slower performance due to function calls.

**Library usage:**

None of the benchmark test cases explicitly uses any external libraries. However, some libraries like Lodash (with its `filter()` method) might be used indirectly through the browser's implementation or global variables.

**Special JS feature or syntax:**

The `Set` data structure is a modern JavaScript feature introduced in ECMAScript 2015 (ES6). It provides an efficient way to store unique values and has caching mechanisms that improve performance. The `filter()` method is also a built-in function in JavaScript, but its usage might vary depending on the browser implementation.

**Other alternatives:**

1. **Sorting and grouping**: Another approach could be sorting the array by the key and then grouping the elements.
2. **Using a mapping function**: A mapping function (e.g., `Array.prototype.map()`) could be used to create a new array with grouped elements.
3. **Reducing an array of groups**: Reducing an array of arrays (i.e., using `Array.prototype.reduce()` or a custom reducer) might also be used to group the elements.

These alternatives would likely have different performance characteristics and may require more or less memory, depending on the implementation details.

Related benchmarks:

group-by (version: 9)

Group arrays by object key

Comparing performance of: groupBy with two while vs groupBy with while and filter vs groupBy with Set and filter vs groupBy with two filters

Created: 3 years ago by: Registered User

Jump to the latest result

groupBy with two while

groupBy with while and filter

groupBy with Set and filter

groupBy with two filters

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):