Benchmark: Object.fromEntries vs reduce - no map

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data));
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
Reduce (reuse object)
Reduce (creating temporary objects)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:100.0) Gecko/20100101 Firefox/100.0

Browser/OS: Firefox 100 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	1510.8 Ops/sec
Reduce (reuse object)	885.4 Ops/sec
Reduce (creating temporary objects)	0.2 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark for you.

**Benchmark Overview**

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

1. `Object.fromEntries`: A built-in JavaScript method that creates an object from an array of [key, value] pairs.
2. `Reduce` with different variations:
	* **Reuse Object**: Uses a reduce function to accumulate the values into an existing object without creating temporary objects.
	* **Creating Temporary Objects**: Uses a reduce function to create a new object for each iteration, which results in more memory allocation and potential performance impact.

**Options Compared**

The benchmark compares the performance of three options:

1. `Object.fromEntries`: A simple, built-in method that creates an object from an array of key-value pairs.
2. **Reuse Object**: Uses a reduce function to accumulate values into an existing object without creating temporary objects.
3. **Creating Temporary Objects**: Uses a reduce function to create a new object for each iteration, which results in more memory allocation.

**Pros and Cons**

1. `Object.fromEntries`:
	* Pros: Simple, efficient, and readable code.
	* Cons: May not be as flexible or customizable as the other options.
2. **Reuse Object**:
	* Pros: Reuses an existing object, reducing memory allocation and garbage collection.
	* Cons: Requires creating a temporary accumulator object, which can lead to slower performance due to frequent object creation and mutation.
3. **Creating Temporary Objects**:
	* Pros: Creates objects on the fly without reusing any existing ones, potentially leading to faster execution times.
	* Cons: Results in more memory allocation, garbage collection, and slower performance due to frequent object creation.

**Library**

There is no specific library used in this benchmark. The `Object.fromEntries` method is a built-in JavaScript feature introduced in ECMAScript 2015 (ES6). The reduce function is also a built-in JavaScript method.

**Special JS Feature or Syntax**

The benchmark uses the `reduce` method, which is a functional programming technique that allows you to iterate over an array and accumulate values into a single object. This syntax is specific to JavaScript and is not directly related to any particular library or framework.

**Other Alternatives**

If you're interested in exploring alternative approaches for creating objects from arrays of key-value pairs, some options include:

* Using the `forEach` method with an arrow function to iterate over the array and create an object.
* Utilizing a library like Lodash, which provides a variety of utility functions for working with arrays and objects.
* Implementing a custom solution using JavaScript's prototype chain or classes.

Keep in mind that these alternatives may not be as efficient or readable as the built-in methods used in this benchmark.

Related benchmarks:

Object.fromEntries vs reduce - no map (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>

Experimental features:

Fastest: N/A

Slowest: N/A

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