Benchmark: Object.fromEntries vs reduce (small dataset)

Script Preparation code:

var data = Array.from(Array(50).keys());

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark that compares the performance of three approaches for creating an object from a dataset:

1. `Object.fromEntries`
2. `reduce` (with a transform function)
3. `reduce` (without transforming data)

The benchmark uses a small dataset of 50 key-value pairs created using `Array.from(Array(50).keys())`.

**Approach 1: Object.fromEntries**

`Object.fromEntries` is a modern JavaScript method that creates an object from an array of key-value pairs. This approach is concise and efficient, as it directly creates the object without the need for intermediate transformations.

Pros:

* Concise and readable code
* Efficient, as it avoids unnecessary memory allocations

Cons:

* May not be supported in older browsers or environments with limited JavaScript features
* Can be slower than other approaches if the input data is large

**Approach 2: reduce (with transform data)**

This approach uses the `reduce` method to iterate over the dataset and create an object. The `transform` function takes each value from the dataset and returns a new value that will be used as the corresponding property in the resulting object.

Pros:

* Can be more flexible than `Object.fromEntries`, as it allows for custom transformations
* May be faster than `Object.fromEntries` if the input data is large

Cons:

* More verbose code compared to `Object.fromEntries`
* Requires creating intermediate objects, which can lead to memory allocations and potential performance issues

**Approach 3: reduce (creating temporary objects)**

This approach is similar to the previous one, but instead of returning a new value from the transform function, it creates a temporary object that is then used as the corresponding property in the resulting object.

Pros:

* Avoids creating intermediate arrays or objects, which can lead to performance issues
* Can be more efficient than `Object.fromEntries` for large datasets

Cons:

* More complex code compared to `Object.fromEntries`
* May require additional memory allocations due to the creation of temporary objects

**Library: Lodash**

The benchmark uses Lodash, a popular JavaScript utility library that provides a wide range of functions for tasks such as string manipulation, array operations, and more. In this case, the `reduce` method is used with an anonymous function as the transform.

Pros:

* Provides a familiar and efficient way to perform iterative operations
* Allows for custom transformations without requiring additional code

Cons:

* Adds additional overhead due to the use of a library
* May not be suitable for all environments or projects

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code is written in standard JavaScript and does not rely on any advanced features or libraries.

**Alternatives**

Other alternatives for creating an object from a dataset include:

1. `Array.prototype.reduce()` without the transform function
2. Using a library like Moment.js to parse dates (not applicable in this case)
3. Using a streaming approach with Web Streams API (not applicable in this case)

The benchmark is designed to compare the performance of different approaches for creating an object from a dataset, making it suitable for developers interested in optimizing JavaScript performance.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.fromEntries (with transform data)	494120.9 Ops/sec
Reduce (reuse object)	594680.9 Ops/sec
Reduce (creating temporary objects)	230514.6 Ops/sec

Related benchmarks:

Object.fromEntries vs reduce (small dataset) (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

Object.fromEntries (with transform data)

Reduce (reuse object)

Reduce (creating temporary objects)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):