Benchmark: Arrays into Object, reduce vs for #2

Script Preparation code:

var ppl = []
for(var i=0; i<10000; i++) {
	ppl.push({ id: i, name: i+"" }) 
}

Tests:

reduce
var byId = ppl.reduce((stored, current) => ({ ...stored, [current.id]: current }), {});
forcycle
var byId = {} for(var i=0;i<ppl.length;i++) { byId[ppl[i].id] = ppl[i] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
forcycle

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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 on MeasureThat.net.

**Benchmark Overview**

The provided JSON represents two test cases for a benchmark that compares the performance of two approaches to create an object from an array: using `Array.prototype.reduce()` and using a `for` loop with indexing. The goal is to determine which approach is faster.

**Options Compared**

Two options are compared:

1. **`reduce()`**: This method applies a user-supplied function to each element in the array, accumulating a value or object.
2. **`forcycle` (for loop with indexing)**: A traditional `for` loop that iterates over the array, assigning each element to an object using its index as the key.

**Pros and Cons of Each Approach**

**`reduce()`**:

Pros:

* More concise and expressive code
* Built-in support for iterating over arrays in a declarative way
* Can be used with various callback functions to manipulate data

Cons:

* May have higher overhead due to function invocation and object creation
* Limited control over iteration order (by default)

**`forcycle`**:

Pros:

* More explicit and predictable control over the iteration process
* Allows for manual assignment of elements to objects
* Can be optimized for specific use cases

Cons:

* More verbose code compared to `reduce()`
* May lead to boilerplate code repetition if not used carefully

**Library and Special JS Feature**

In this benchmark, no libraries are explicitly mentioned, but it's possible that the `Array.prototype.reduce()` method relies on internal implementations provided by the ECMAScript standard.

No special JavaScript features are used in these test cases.

**Benchmark Preparation Code**

The provided script preparation code creates an array of 10,000 objects with unique `id` and `name` properties:
```javascript
var ppl = [];
for (var i = 0; i < 10000; i++) {
    ppl.push({ id: i, name: i + "" });
}
```
The HTML preparation code is not specified, as it's likely that the benchmark runs in a browser environment with an existing DOM.

**Latest Benchmark Result**

The latest result shows two test cases:

1. `forcycle`: With 327 executions per second on a Chrome 85 browser on a Windows desktop.
2. `reduce()`: With 36 executions per second on the same browser and hardware configuration.

These results suggest that, in this specific case, the `forcycle` approach is significantly faster than using `Array.prototype.reduce()`.

**Other Alternatives**

If you're interested in exploring other approaches for creating an object from an array, consider these alternatives:

* Using `Object.assign()` or `Array.prototype.map()`
* Implementing a custom loop with manual indexing and assignment
* Utilizing library functions like `lodash` or `ramda`

Keep in mind that the best approach depends on your specific use case and performance requirements. MeasureThat.net's benchmark results can serve as a starting point for further optimization and exploration.

Related benchmarks:

Arrays into Object, reduce vs for #2 (version: 0)

https://www.youtube.com/watch?v=5nzBDkH9lWI

Comparing performance of: reduce vs forcycle

Created: 5 years ago by: Guest

Jump to the latest result

reduce

forcycle

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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