Benchmark: Object mapping : reduce ( object reuse ) VS. no reuse VS. fromEntries+map

Script Preparation code:

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

AخA
 
var obj = {  ...Array.from(Array(10000).keys())};

Tests:

reduce (object reuse)
Object.entries(obj).reduce((acc, [k, v]) => { acc[k] = v; return acc; }, {});
Object.entries(obj).reduce((acc, [k, v]) => {
acc[k] = v;
return acc;
}, {});
reduce (no reuse)
Object.entries(obj).reduce((acc, [k, v]) => ({ ...acc, [k]: v, }), {});
Object.entries(obj).reduce((acc, [k, v]) => ({
...acc,
[k]: v,
}), {});

fromEntries

Object.fromEntries(
	Object.entries(obj).map(
    	([k, v]) => [k, v]
    )
);

 
Object.fromEntries(    Object.entries(obj).map(        ([k, v]) => [k, v]    ));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
reduce (object reuse)
reduce (no reuse)
fromEntries

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 86 on Windows

View result in a separate tab

Test name	Executions per second
reduce (object reuse)	786.5 Ops/sec
reduce (no reuse)	31.5 Ops/sec
fromEntries	402.5 Ops/sec

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

Benchmark Overview

The provided JSON represents a JavaScript microbenchmarking test case, where the goal is to compare the performance of three different approaches for object mapping: reducing an object using Object.entries and reduce, with and without reusing the accumulator.

Test Cases

There are three test cases:

"reduce (object reuse)": This test case uses the original approach of reducing the object using Object.entries and reduce, where the accumulator is reused.
"reduce (no reuse)": This test case modifies the original approach by not reusing the accumulator, resulting in a new object being created on each iteration.
**"fromEntries+map": This test case uses a more modern approach of creating an object from an array of key-value pairs using Object.fromEntries` and mapping over the array to create individual key-value pairs.

Options Compared

The three test cases are compared in terms of their performance, measured by the number of executions per second.

Pros and Cons

"reduce (object reuse)": This approach reuses the accumulator, which can lead to better performance due to reduced object creation overhead. However, it may also lead to incorrect results if the accumulator is modified unexpectedly.
"reduce (no reuse)": This approach creates a new object on each iteration, which can be slower due to object creation overhead. However, it ensures that the result is accurate and predictable.
**"fromEntries+map": This approach uses modern JavaScript features to create an object from an array of key-value pairs. It may provide better performance than the traditional reduce` approach, but its performance depends on the specific use case.

Libraries and Features

None of the test cases use any external libraries or special JS features other than the built-in Object.entries, Object.fromEntries, and Array.prototype.map methods.

Other Considerations

Object creation overhead: The performance difference between reusing and not reusing the accumulator can be significant due to object creation overhead.
Predictability and accuracy: Using a reusable accumulator ensures predictability and accuracy, while not reusing it may lead to unexpected behavior or incorrect results.

Alternatives

Other alternatives for comparing performance include:

Using Object.assign instead of reduce
Comparing the performance of different JavaScript engines (e.g., V8 vs. SpiderMonkey)
Adding more test cases with varying input sizes and shapes
Using a profiling tool to analyze the execution time and memory usage of each approach

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case, where the goal is to compare the performance of three different approaches for object mapping: reducing an object using `Object.entries` and `reduce`, with and without reusing the accumulator.

**Test Cases**

There are three test cases:

1. **"reduce (object reuse)"**: This test case uses the original approach of reducing the object using `Object.entries` and `reduce`, where the accumulator is reused.
2. **"reduce (no reuse)"**: This test case modifies the original approach by not reusing the accumulator, resulting in a new object being created on each iteration.
3. **"fromEntries+map"`: This test case uses a more modern approach of creating an object from an array of key-value pairs using `Object.fromEntries` and mapping over the array to create individual key-value pairs.

**Options Compared**

The three test cases are compared in terms of their performance, measured by the number of executions per second.

**Pros and Cons**

* **"reduce (object reuse)"**: This approach reuses the accumulator, which can lead to better performance due to reduced object creation overhead. However, it may also lead to incorrect results if the accumulator is modified unexpectedly.
* **"reduce (no reuse)"**: This approach creates a new object on each iteration, which can be slower due to object creation overhead. However, it ensures that the result is accurate and predictable.
* **"fromEntries+map"`: This approach uses modern JavaScript features to create an object from an array of key-value pairs. It may provide better performance than the traditional `reduce` approach, but its performance depends on the specific use case.

**Libraries and Features**

None of the test cases use any external libraries or special JS features other than the built-in `Object.entries`, `Object.fromEntries`, and `Array.prototype.map` methods.

**Other Considerations**

* **Object creation overhead**: The performance difference between reusing and not reusing the accumulator can be significant due to object creation overhead.
* **Predictability and accuracy**: Using a reusable accumulator ensures predictability and accuracy, while not reusing it may lead to unexpected behavior or incorrect results.

**Alternatives**

Other alternatives for comparing performance include:

* Using `Object.assign` instead of `reduce`
* Comparing the performance of different JavaScript engines (e.g., V8 vs. SpiderMonkey)
* Adding more test cases with varying input sizes and shapes
* Using a profiling tool to analyze the execution time and memory usage of each approach

Related benchmarks:

Object mapping : reduce ( object reuse ) VS. no reuse VS. fromEntries+map (version: 0)

Comparing performance of: reduce (object reuse) vs reduce (no reuse) vs fromEntries

Created: 4 years ago by: Guest

Jump to the latest result

reduce (object reuse)

reduce (no reuse)