Benchmark: Object.fromEntries vs reduce

Script Preparation code:

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

Tests:

Object.fromEntries
Object.fromEntries(Object.entries(data).map((key, value) => [key, value]));
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() }), {});

Historical Performance Data aggregated from 630 community runs

Desktop Results:

Chrome 502 runs

Reduce (reuse object)

3K/s

Object.fromEntries

298/s

Reduce (creating temporary objects)

93/s

Fastest: Reduce (reuse object) (29.3x faster)

View exact numbers

✓ Reduce (reuse object): 2,724 ops/sec
• Object.fromEntries: 298 ops/sec
• Reduce (creating temporary objects): 93 ops/sec

Firefox 98 runs

Reduce (reuse object)

2K/s

Object.fromEntries

345/s

Reduce (creating temporary objects)

0/s

Fastest: Reduce (reuse object) (5091.5x faster)

View exact numbers

✓ Reduce (reuse object): 1,870 ops/sec
• Object.fromEntries: 345 ops/sec
• Reduce (creating temporary objects): 0 ops/sec

Safari 13 runs

Reduce (reuse object)

601/s

Object.fromEntries

346/s

Reduce (creating temporary objects)

0/s

Fastest: Reduce (reuse object) (2899.3x faster)

View exact numbers

✓ Reduce (reuse object): 601 ops/sec
• Object.fromEntries: 346 ops/sec
• Reduce (creating temporary objects): 0 ops/sec

Other 5 runs

Reduce (reuse object)

2K/s

Object.fromEntries

270/s

Reduce (creating temporary objects)

74/s

Fastest: Reduce (reuse object) (32.6x faster)

View exact numbers

✓ Reduce (reuse object): 2,399 ops/sec
• Object.fromEntries: 270 ops/sec
• Reduce (creating temporary objects): 74 ops/sec

Mobile Results:

Chrome 12 runs

Reduce (reuse object)

856/s

Object.fromEntries

179/s

Reduce (creating temporary objects)

17/s

Fastest: Reduce (reuse object) (50.5x faster)

View exact numbers

✓ Reduce (reuse object): 856 ops/sec
• Object.fromEntries: 179 ops/sec
• Reduce (creating temporary objects): 17 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 28 days ago)

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

Browser/OS: Chrome 149 on Mac OS X 10.15.7

View result in a separate tab

Reduce (reuse object)

3K/s

Object.fromEntries

485/s

Reduce (creating temporary objects)

161/s

View exact numbers

Test name	Executions per second
✓ Reduce (reuse object)	3,457 Ops/sec
Object.fromEntries	485 Ops/sec
Reduce (creating temporary objects)	161 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is tested, compared, and the pros and cons of different approaches.

**Benchmark Definition**

The benchmark definition consists of three test cases:

1. `Object.fromEntries`: This method creates an object from an array of key-value pairs.
2. `Reduce (reuse object)`: This method uses the reduce() function to create a new object by iterating over the entries of the input data and adding each value as a property to the accumulator object.
3. `Reduce (creating temporary objects)`: Similar to the previous test case, but instead of reusing the accumulator object, it creates a new temporary object for each iteration.

**Options Compared**

The three options are compared in terms of their performance, which is measured by the number of executions per second.

* `Object.fromEntries`: This method is likely to be faster since it avoids the overhead of creating and manipulating intermediate objects.
* `Reduce (reuse object)`: This approach can lead to slower performance due to the reuse of the accumulator object, which may involve more memory allocations and garbage collection.
* `Reduce (creating temporary objects)`: This option creates a new temporary object for each iteration, which can be slower than reusing an existing object.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* `Object.fromEntries`:
	+ Pros: likely to be faster due to reduced overhead.
	+ Cons: may not handle edge cases as well as other methods.
* `Reduce (reuse object)`: 
	+ Pros: may provide better performance for certain use cases, e.g., when memory is limited.
	+ Cons: can lead to slower performance and increased memory usage.
* `Reduce (creating temporary objects)`:
	+ Pros: avoids potential issues with reusing accumulator objects.
	+ Cons: likely to be slower due to the creation of intermediate objects.

**Library Usage**

None of the test cases explicitly use a library. However, it's worth noting that the `Array.from()` method is used in one of the benchmark definitions, which is a built-in JavaScript method.

**Special JS Features or Syntax**

There are no specific special JS features or syntax mentioned in the provided data.

Object.fromEntries vs reduce (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Historical Performance Data aggregated from 630 community runs

Desktop Results:

Chrome 502 runs

Firefox 98 runs

Safari 13 runs

Other 5 runs

Mobile Results:

Chrome 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Object.fromEntries vs reduce (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

Object.fromEntries

Reduce (reuse object)

Reduce (creating temporary objects)

Historical Performance Data aggregated from 630 community runs

Desktop Results:

Chrome 502 runs

Firefox 98 runs

Safari 13 runs

Other 5 runs

Mobile Results:

Chrome 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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