Benchmark: rooms flatmap vs reduce

Script Preparation code:

var test = Array.from({
    length: 10
}, () => ({
    rooms: Array.from({
        length: 15
    }, () => ({
        room: {
            id: Math.floor(Math.random() * 10000)
        }
    }))
}))

Tests:

reduce
test.reduce( (acc, page) => ({ ...acc, ...page.rooms.reduce( (acc, item) => ({ ...acc, [item.room.id]: item }), {} ) }), {} )
flatmap
Object.fromEntries( (test.flatMap(page => page.rooms) ?? []).map(room => [room.room.id, room]) )

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
flatmap

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a complex task, and BenchmarkThat.net provides a great platform for comparing different approaches.

The provided JSON represents two test cases:

1. **`flatmap`**: This test case uses the `flatMap()` method to transform an array of rooms into an object with room IDs as keys.
2. **`reduce`**: This test case uses the `reduce()` method to accumulate data from an array of rooms.

**Options compared:**

In the `flatmap` test case, two approaches are compared:

a. **`Object.fromEntries()`**: This method is used to create a new object from key-value pairs.
b. **`Array.prototype.reduce()`**: This method is used to iterate over an array and accumulate data.

In the `reduce` test case, only one approach is compared:

c. **`Array.prototype.reduce()`**: Same as above, but with a different script preparation code.

**Pros and cons of each approach:**

a. **`Object.fromEntries()`**

Pros:

* Faster execution time
* More concise syntax

Cons:

* May not be supported in older browsers or environments that don't have the latest JavaScript standards (ECMAScript 2022)
* Can throw errors if the input array is empty

b. **`Array.prototype.reduce()`**

Pros:

* Wide support across browsers and environments
* Can handle arbitrary data types
* More flexible syntax

Cons:

* Typically slower execution time compared to `Object.fromEntries()`
* Requires more code to achieve the same result

c. **`Array.prototype.reduce()`** (same as above)

**Library usage:**

In both test cases, no libraries are explicitly mentioned. However, it's worth noting that the `flatMap()` method was introduced in ECMAScript 2019 (ES10), which means older browsers may not support it.

**Special JS feature or syntax:**

None mentioned in this specific benchmark. Both tests use standard JavaScript features and syntax.

**Other alternatives:**

For the `flatmap` test case, other alternatives could include:

* Using `Array.prototype.map()` followed by `Object.fromEntries()`
* Using a library like Lodash's `mapKeys()` method

For the `reduce` test case, other alternatives could include:

* Using `Array.prototype.reduceRight()` for a different order of accumulation
* Using a library like Lodash's `reduce()` method with additional utility functions

Related benchmarks:

rooms flatmap vs reduce (version: 0)

Comparing performance of: reduce vs flatmap

Created: 3 years ago by: Guest

Jump to the latest result

reduce

flatmap

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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