Benchmark: array indexing forEach vs reduce 2

Script Preparation code:

var arr = [];
for (id=1;id<1000;id++) arr.push({id,name:Math.random().toString(36).substring(7)})
var pk = 'id,name';
var pkarr = pk.split(',')
var acc={};

Tests:

reduce array key
arr.reduce((acc,row) => { acc[pkarr.map((col)=>row[col]).join(',')]=row; return acc; },{})
foreach array key
arr.forEach(row => acc[pkarr.map((col)=>row[col]).join(',')]=row);
foreach simple key
arr.forEach(row => acc[row.id+','+row.name]=row);
foreach simple template
arr.forEach(row => acc[`${row.id},${row.name}`]=row);
reduce simple key
arr.reduce((acc,row) => { acc[row.id+','+row.name]=row; return acc; },{})
reduce simple template
arr.reduce((acc,row) => { acc[`${row.id},${row.name}`]=row; return acc; },{})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce array key
foreach array key
foreach simple key
foreach simple template
reduce simple key
reduce simple template

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:79.0) Gecko/20100101 Firefox/79.0

Browser/OS: Firefox 79 on Windows

View result in a separate tab

Test name	Executions per second
reduce array key	2490.5 Ops/sec
foreach array key	3808.1 Ops/sec
foreach simple key	5740.2 Ops/sec
foreach simple template	5790.3 Ops/sec
reduce simple key	3417.8 Ops/sec
reduce simple template	3393.7 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its options.

**Benchmark Overview**

The benchmark, called "array indexing forEach vs reduce 2", tests two approaches for iterating over an array and updating an object: `forEach` and `reduce`. The test case creates a large array of objects with random properties (`id` and `name`) and measures how many times each operation is executed.

**Options Compared**

The benchmark compares the following options:

1. **`arr.forEach(row => acc[pkarr.map((col)=>row[col]).join(',')]=row)`**: This option uses the `forEach` method to iterate over the array and update the `acc` object with a key generated from the `id` and `name` properties.
2. **`arr.reduce((acc,row) => {\r\n  acc[pkarr.map((col)=>row[col]).join(',')]=row;\r\n  return acc;\r\n},{})`**: This option uses the `reduce` method to iterate over the array and update the `acc` object with a key generated from the `id` and `name` properties.
3. **`arr.forEach(row => acc[row.id+','+row.name]=row)`**: Similar to the first option, but uses template literals to generate the key instead of an array manipulation function.
4. **`arr.reduce((acc,row) => {\r\n  acc[row.id+','+row.name]=row;\r\n  return acc;\r\n},{})`**: Similar to the second option, but uses template literals to generate the key instead of an array manipulation function.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

* **`forEach` options (1 and 3)**:
	+ Pros: Easy to understand and implement, flexible key generation.
	+ Cons: May be slower due to the overhead of the `forEach` method, less efficient memory allocation.
* **`reduce` options (2 and 4)**:
	+ Pros: More efficient memory allocation, potentially faster execution times.
	+ Cons: Requires understanding of the `reduce` method and its use cases, more complex key generation.

**Library**

The benchmark uses the `Math.random()` function to generate random numbers for the array elements' properties (`id` and `name`). There are no explicit libraries used in this benchmark.

**Special JS Feature or Syntax**

The benchmark uses template literals (e.g., `${row.id},${row.name}`) to generate keys. This is a modern JavaScript feature introduced in ECMAScript 2015 (ES6).

**Other Alternatives**

If you're interested in exploring alternative approaches, here are some options:

* **`for...of` loop**: Another iteration method that can be used to iterate over arrays.
* **`map()` and `then()`**: A combination of the `map()` method and the `then()` method can be used to perform operations on an array and update an object.
* **`promises`**: Using promises with async/await syntax can provide a more efficient way to handle asynchronous operations, but may require additional setup.

Please note that this is not an exhaustive list, and there are many other ways to approach this benchmark.

Related benchmarks:

array indexing forEach vs reduce 2 (version: 1)

Comparing performance of: reduce array key vs foreach array key vs foreach simple key vs foreach simple template vs reduce simple key vs reduce simple template

Created: 4 years ago by: Registered User

Jump to the latest result

reduce array key

foreach array key

foreach simple key

foreach simple template

reduce simple key

reduce simple template

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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