Benchmark: reduce vs for to mapify array

Script Preparation code:

var arr = [];

for(i=0; i<500; i++){
  arr.push({
    id: Math.random().toString(36).slice(2),
    other_data: {}
  });
}

Tests:

reduce
var mapped_reduce = arr.reduce((acc,val) => { return {...acc,[val.id]:val} },{})
for
var mapped_for = {}; for (let i = 0; i < arr.length; i++) { mapped_for[arr[i].id] = arr[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
for

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. The benchmark tests the performance difference between using the `Array.prototype.reduce()` method and a traditional `for` loop to transform an array into an object with nested key-value pairs.

**Test Options Compared:**

Two test options are compared:

1. **Reduce**: This option uses the `Array.prototype.reduce()` method, which is a concise way to apply a function to each element of an array, accumulating a result.
2. **For**: This option uses a traditional `for` loop to iterate over the array elements and create the resulting object.

**Pros and Cons:**

* **Reduce**: This approach has several advantages:
	+ Concise code that is easy to read and write.
	+ Efficient use of CPU resources, as it avoids unnecessary iterations.
	+ Supports more complex transformations and aggregations.
However, there are some potential drawbacks:
	+ May not be supported in older browsers or versions of JavaScript.
	+ Can be slower for very large datasets due to the overhead of recursive function calls.
* **For**: This approach has several advantages:
	+ Wide browser support, including older versions of JavaScript.
	+ Can be faster for very large datasets, as it avoids the overhead of recursive function calls.
However, there are some potential drawbacks:
	+ More verbose code that is harder to read and write.
	+ May be slower due to the need for explicit iteration.

**Library Usage:**

None of the test cases uses any external libraries. The `Array.prototype.reduce()` method is a built-in JavaScript API.

**Special JS Features or Syntax:**

The `reduce()` method uses a special syntax called "arrow functions" (introduced in ECMAScript 2015), which allows for concise and expressive function definitions. However, the `for` loop does not use any special syntax.

**Other Alternatives:**

If you want to test other approaches, here are some alternatives:

* **Lodash**: You could create a separate test case that uses Lodash's `mapValues()` method or the `reduce()` method from Lodash.
* **Closures**: Another approach could be to use closures to transform the array elements without using `Array.prototype.reduce()`.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Safari/605.1.15

Browser/OS: Safari 12 on Mac OS X 10.14.4

View result in a separate tab

Test name	Executions per second
reduce	35.5 Ops/sec
for	5230.4 Ops/sec

Related benchmarks:

reduce vs for to mapify array (version: 0)

Comparing performance of: reduce vs for

Created: 5 years ago by: Registered User

Jump to the latest result

reduce

for

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):