Benchmark: array.map() with spread vs for-loop v2

Script Preparation code:

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

Tests:

Object.fromEntries with spread
const obj = Object.fromEntries([ ...entries.map(([key, value]) => [key, value]) ]);
for-loop and object (reuse object)
const obj = {}; for (const [key, value] of entries) { obj[key] = value; }
for-loop and object (creating temporary objects)
let obj = {}; for (const [key, value] of entries) { obj = { ...obj, [key]: value }; }
for-loop and map
const map = new Map(); for (const [key, value] of entries) { map.set(key, value); } const obj = Object.fromEntries(map);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries with spread
for-loop and object (reuse object)
for-loop and object (creating temporary objects)
for-loop and map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark measures the performance of different approaches to create an object from an array of key-value pairs:

* `Object.fromEntries` with spread operator (`[...entries.map(([key, value]) => [key, value])]`)
* For loop with object creation and assignment (`const obj = {}; for (const [key, value] of entries) { obj[key] = value; }`)
* For loop with object creation and temporary objects (`let obj = {}; for (const [key, value] of entries) { obj = { ...obj, [key]: value }; }`)
* For loop with `Map` object creation and conversion to an object (`const map = new Map(); for (const [key, value] of entries) { map.set(key, value); } const obj = Object.fromEntries(map)`)

**Options Compared**

The four options are compared:

1. **Object.fromEntries with spread**: This approach uses the spread operator to create a new array of key-value pairs from the `entries` array.
2. **For loop with object creation and assignment**: This approach creates an empty object and iterates over the `entries` array, assigning each value to the corresponding key in the object.
3. **For loop with object creation and temporary objects**: This approach creates a new object on each iteration, using the spread operator to create a copy of the previous object and then modifying it with the new key-value pair.
4. **For loop with Map object creation and conversion**: This approach creates an empty `Map` object, iterates over the `entries` array, sets each value in the map, and then converts the map to an object using `Object.fromEntries`.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Object.fromEntries with spread**:
	* Pros: Fast, concise, and expressive.
	* Cons: May not be optimized for performance, can lead to memory issues if dealing with large datasets.
2. **For loop with object creation and assignment**:
	* Pros: Easy to understand, well-supported in most browsers.
	* Cons: Can be slow due to the overhead of creating a new object on each iteration.
3. **For loop with object creation and temporary objects**:
	* Pros: Avoids memory issues with large datasets, but can be slower due to the spread operator.
	* Cons: May not be as concise or expressive as other approaches.
4. **For loop with Map object creation and conversion**:
	* Pros: Fast, efficient, and well-suited for large datasets.
	* Cons: Less intuitive than other approaches, may require additional setup.

**Library Usage**

None of the provided benchmark tests use a specific library, but `Object.fromEntries` is a built-in JavaScript method that is supported by most browsers.

**Special JS Features or Syntax**

None of the provided benchmark tests use any special JavaScript features or syntax beyond the standard language.

**Other Considerations**

When choosing an approach for creating an object from an array of key-value pairs, consider factors such as:

* Performance: For large datasets, `Object.fromEntries` with spread may be slower than other approaches.
* Memory usage: Avoid using temporary objects if dealing with large datasets to avoid memory issues.
* Code readability and maintainability: Choose an approach that is concise, expressive, and easy to understand.

Other alternatives for creating an object from an array of key-value pairs include:

* `Array.reduce()`: A functional programming approach that creates a single object by reducing the array into key-value pairs.
* `Array.forEach()`: A non-standard approach that uses the `forEach()` method to iterate over the array and create an object by assigning each value to a key.
* Other library functions, such as `lodash.object.fromPairs()` or ` Ramda.mapKeys()`.

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Linux

View result in a separate tab

Test name	Executions per second
Object.fromEntries with spread	1665.7 Ops/sec
for-loop and object (reuse object)	11159.5 Ops/sec
for-loop and object (creating temporary objects)	73.9 Ops/sec
for-loop and map	1114.3 Ops/sec

Related benchmarks:

array.map() with spread vs for-loop v2 (version: 0)

Comparing performance of: Object.fromEntries with spread vs for-loop and object (reuse object) vs for-loop and object (creating temporary objects) vs for-loop and map

Created: 8 months ago by: Guest

Jump to the latest result

Object.fromEntries with spread

for-loop and object (reuse object)

for-loop and object (creating temporary objects)

for-loop and map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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