Benchmark: reduce vs map + fromEntries + forEach

Script Preparation code:

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

Tests:

reduce
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v.toString(); return acc; }, {});
map + fromEntries
Object.fromEntries(Object.entries(data).map(([k, v]) => ([k, v.toString()])));
forEach
let acc = {} Object.entries(data).forEach((k, v) => { acc[k] = v.toString() })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
map + fromEntries
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 88 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce	739.8 Ops/sec
map + fromEntries	412.7 Ops/sec
forEach	98.1 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net provides a platform for creating and running JavaScript microbenchmarks. The provided benchmark compares three approaches to transform an object from an array of key-value pairs into a single object with transformed values.

**Test Case Breakdown**

There are three test cases:

1. **reduce**: Uses the `Array.prototype.reduce()` method to iterate over the array of key-value pairs and accumulate the transformed values in an object.
2. **map + fromEntries**: First uses `Array.prototype.map()` to transform each value, then creates a new object using `Object.fromEntries()` with the mapped values as key-value pairs.
3. **forEach**: Uses `Array.prototype.forEach()` to iterate over the array of key-value pairs and accumulate the transformed values in an object.

**Comparison Options**

The benchmark compares three approaches:

*   **reduce**: Iterates over the array, accumulating transformed values in an object using a callback function.
*   **map + fromEntries**: Transforms each value using `Array.prototype.map()` and creates a new object using `Object.fromEntries()`.
*   **forEach**: Iterates over the array, accumulating transformed values in an object using a callback function.

**Pros and Cons**

Here are some pros and cons of each approach:

*   **reduce**:
    *   Pros:
        *   Efficient use of memory, as it accumulates values in a single object.
        *   Can be faster due to the absence of the overhead of creating a new object.
    *   Cons:
        *   May have issues with handling duplicate keys or NaN values.
*   **map + fromEntries**:
    *   Pros:
        *   Robust handling of key-value pairs, including duplicate keys and NaN values.
        *   Can be faster due to the parallelization of the map operation.
    *   Cons:
        *   Creates a new object using `Object.fromEntries()`, which may incur memory overhead.
*   **forEach**:
    *   Pros:
        *   Robust handling of key-value pairs, including duplicate keys and NaN values.
        *   Can be faster due to the parallelization of the map operation (although it's not as effective as `map + fromEntries`).
    *   Cons:
        *   Accumulates values in an object, which may lead to memory issues for large inputs.

**Library Used**

None. This benchmark is a built-in feature of MeasureThat.net.

**Special JS Features or Syntax**

No special features or syntax are used in this benchmark.

**Alternative Approaches**

Other possible approaches to transform the input array into a single object with transformed values could be:

*   Using `Array.prototype.reduce()` and creating an object using `Object.assign()`
*   Using `Array.prototype.forEach()` with an object's `push` method to accumulate transformed values
*   Using a custom iterative approach without relying on built-in methods

However, these alternatives are not tested in the provided benchmark.

Related benchmarks:

reduce vs map + fromEntries + forEach (version: 0)

Comparing performance of: reduce vs map + fromEntries vs forEach

Created: 3 years ago by: Guest

Jump to the latest result

reduce

map + fromEntries

forEach

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