Benchmark: Object.fromEntries vs forEach vs For Loop

Script Preparation code:

var columns = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
var rows = Array.from(Array(10000)).map((i) => [...columns]);

Tests:

Object.fromEntries
rows.map((row) => Object.fromEntries(row.map((value, i) => [columns[i], value])));
For Each
rows.map((row) => { const obj = {}; row.forEach((value, i) => { obj[columns[i]] = value; }); return obj; });
For loop
rows.map((row) => { const obj = {}; for (let i = 0; i < columns.length; i++) { obj[columns[i]] = row[i]; } return obj; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
For Each
For loop

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.

**Benchmark Definition**

The benchmark tests three different approaches to populate an object from an array of key-value pairs:

1. `Object.fromEntries`
2. `forEach` loop
3. For Loop

Each approach is tested on a sample dataset consisting of 10,000 rows with 26 unique values (from the alphabet).

**Options Compared**

The benchmark compares the performance of three different approaches:

* `Object.fromEntries`: a built-in JavaScript method that creates an object from key-value pairs.
* `forEach` loop: a common approach to iterate over an array and populate an object.
* For Loop: another traditional way to iterate over an array and assign values to an object.

**Pros and Cons**

1. **Object.fromEntries**:
	* Pros:
		+ Concise and readable code
		+ Performance is often better than other approaches (as seen in the benchmark results)
	* Cons:
		+ Limited browser support (some older browsers may not have this method)
		+ May be slower for very large datasets due to the overhead of creating an object iterator
2. **forEach** loop:
	* Pros:
		+ Easy to understand and implement
	* Cons:
		+ May require more lines of code compared to `Object.fromEntries`
		+ Can be slower than other approaches if not optimized properly (e.g., using `let` declaration instead of `var`)
3. For Loop:
	* Pros:
		+ Often faster than `forEach` loop due to the overhead of function calls
	* Cons:
		+ More verbose and less readable code
		+ May require more iterations to ensure all values are assigned

**Library**

None, this benchmark only uses built-in JavaScript features.

**Special JS Features or Syntax**

The benchmark does not use any special JavaScript features or syntax. However, it's worth noting that `Object.fromEntries` was introduced in ECMAScript 2015 (ES6) and may have different behavior in older browsers.

**Benchmark Results**

According to the latest benchmark results:

* For Loop is the fastest approach, with an average of 33 executions per second.
* Object.fromEntries is slightly slower than For Loop but still outperforms the `forEach` loop, with an average of 17 executions per second.
* The `forEach` loop is the slowest approach in this benchmark.

**Other Alternatives**

If you're looking for alternative approaches to populate an object from key-value pairs, some other options include:

* Using a library like Lodash's `mapValues` method
* Utilizing a more complex data structure, such as a Map or a reduce() function
* Employing a caching mechanism to store frequently accessed values

Keep in mind that the best approach will depend on your specific use case and performance requirements.

Related benchmarks:

Object.fromEntries vs forEach vs For Loop (version: 0)

Comparing performance of: Object.fromEntries vs For Each vs For loop

Created: 2 years ago by: Guest

Jump to the latest result

Object.fromEntries

For Each

For loop

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