Benchmark: Object.fromEntries vs reduce with keys as indexes

Script Preparation code:

var data = [{
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}, {
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}, {
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}, {
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}, {
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}, {
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1,
    test: 1
}]

Tests:

With reduce with an id inside the object
data.reduce((previousKeys, actualKey, indexKey) => { previousKeys[ indexKey ] = { id: indexKey, order: indexKey, ...actualKey }; return previousKeys; }, {});
with Object.fromEntries ( array.map( ... ) ) with an id inside the object
Object.fromEntries(data.map((key, value) => [ value, { id: value, ...key } ]));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
With reduce with an id inside the object
with Object.fromEntries ( array.map( ... ) ) with an id inside the object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36

Browser/OS: Chrome 93 on Windows

View result in a separate tab

Test name	Executions per second
With reduce with an id inside the object	1402141.2 Ops/sec
with Object.fromEntries ( array.map( ... ) ) with an id inside the object	935954.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different JavaScript methods can be complex, and it's great that you're exploring alternatives.

The provided JSON represents two benchmark definitions:

1. **Object.fromEntries vs reduce with keys as indexes**: This benchmark compares the performance of `Object.fromEntries` against a custom implementation using `reduce`. Both methods are used to create an object from an array of key-value pairs, where each key is also an index.
2. Two individual test cases:
	* "With reduce with an id inside the object"
	* "with Object.fromEntries ( array.map( ... ) ) with an id inside the object"

Let's break down what's being tested:

**Object.fromEntries vs reduce with keys as indexes**

In this benchmark, we're comparing two methods to create an object from an array of key-value pairs. The `reduce` method is used to iterate over the array and accumulate the values into a new object. In this case, each key is also an index.

Pros of using `Object.fromEntries`:

* Shorter syntax and more readable
* Faster execution, since it's implemented in native code

Cons of using `Object.fromEntries`:

* Limited control over the creation process (e.g., no option to ignore null or undefined values)
* May not be compatible with older browsers

Pros of using a custom implementation with `reduce`:

* More control over the creation process
* Can handle edge cases and custom logic

Cons of using a custom implementation with `reduce`:

* Longer syntax, potentially less readable
* Slower execution, since it's implemented in JavaScript

**Individual test cases**

These two test cases use the same input data but apply different methods to create the object.

1. "With reduce with an id inside the object"
	* This test case uses a custom implementation of `reduce` that takes an additional `id` parameter for each key-value pair.
	* The purpose is to compare the performance of this custom implementation against `Object.fromEntries`.
2. "with Object.fromEntries ( array.map( ... ) ) with an id inside the object"
	* This test case uses a more concise syntax, leveraging the `map()` method and `Object.fromEntries()` in combination.
	* The purpose is to compare the performance of this concise syntax against the custom implementation with `reduce`.

**Library used**

In both benchmark definitions, the library used is **JavaScript**, which is executed by the browser or Node.js.

**Special JS feature or syntax**

The test case "with Object.fromEntries ( array.map( ... ) ) with an id inside the object" uses a shorthand syntax for mapping an array of values and creating a new array of key-value pairs. This syntax is available in ECMAScript 2015+.

Other alternatives to explore:

* **Array.prototype.reduce()**: Another method for accumulating values into a new object, but it has some differences in behavior compared to the custom implementation.
* **Array.prototype.forEach()**: A simple iteration method that can be used to create an object from an array of key-value pairs, but it may not be as efficient or readable as `reduce` or `Object.fromEntries`.
* **Lodash.cloneDeep()**: A library function that creates a deep clone of an object, which could potentially be used for this benchmark.
* **Other native methods**: Depending on the specific requirements and constraints, other native JavaScript methods like `Array.prototype.reduce()` or `String.prototype.split()` might also be considered.

When choosing between these alternatives, consider factors such as:

* Readability: How readable is each implementation?
* Performance: Which method executes faster?
* Maintainability: Is it easier to maintain and update the code with a specific implementation?

Feel free to ask if you'd like me to elaborate on any of these points or provide further insights!

Related benchmarks:

Object.fromEntries vs reduce with keys as indexes (version: 0)

Comparing performance of: With reduce with an id inside the object vs with Object.fromEntries ( array.map( ... ) ) with an id inside the object

Created: 3 years ago by: Guest

Jump to the latest result

With reduce with an id inside the object

with Object.fromEntries ( array.map( ... ) ) with an id inside the object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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