Benchmark: Object.fromEntries vs reduce without toString2

Script Preparation code:

var data = { ...Array.from(Array(10000).keys()) };

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
Reduce (reuse object)
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v; return acc; }, {});
Reduce (creating temporary objects)
Object.entries(data).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
Reduce (reuse object)
Reduce (creating temporary objects)

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 break down the provided benchmark JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is defined by three test cases:

1. `Object.fromEntries`: This test case creates an object from an array of key-value pairs using the `Object.fromEntries` method.
2. `Reduce (reuse object)`: This test case uses the `reduce` method to create a new object by iterating over the `data` array and assigning each value to a property of the accumulator object.
3. `Reduce (creating temporary objects)` : This test case is similar to the previous one, but it creates a new temporary object for each iteration instead of reusing the same accumulator.

**Options compared**

In this benchmark, two main approaches are being tested:

1. **Object.fromEntries**: This approach uses the `Object.fromEntries` method, which creates an object from an array of key-value pairs in a single operation.
2. **Reduce**: This approach uses the `reduce` method to create a new object by iterating over the `data` array and assigning each value to a property of the accumulator object.

**Pros and Cons**

* **Object.fromEntries**:
	+ Pros: Fast, concise, and readable syntax.
	+ Cons: May not be supported in older browsers or environments.
* **Reduce**:
	+ Pros: Can be more flexible and efficient for certain use cases.
	+ Cons: Requires more boilerplate code and can be less readable.

**Library**

In this benchmark, the `Array.from()` method is used, which is a part of the ECMAScript standard and is widely supported in modern browsers. The `reduce` method is also part of the ECMAScript standard and is widely supported.

**Special JS feature or syntax**

The `Object.fromEntries` method was introduced in ECMAScript 2015 (ES6) and has since become a standard feature. It's a concise way to create an object from an array of key-value pairs.

Overall, this benchmark tests the performance of two different approaches to creating objects from arrays: using `Object.fromEntries` versus using the `reduce` method.

Related benchmarks:

Object.fromEntries vs reduce without toString2 (version: 0)

Comparing performance of: Object.fromEntries vs Reduce (reuse object) vs Reduce (creating temporary objects)

Created: 4 years ago by: Guest

Jump to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

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