Benchmark: Reduce vs map with Object.assign 1

Tests:

Reduce
const answers = [ { "uuid": "38913ba2-98fa-48b3-bb2a-ac9d550a1e1a", "answers": [ { "questionUuid": "097707bb-c20d-41a5-8dad-22e2b54dcfd4", "value": "2022-06-04T12:00:00+01:00" }, { "questionUuid": "c6866d6f-dadf-457c-9ef5-4973b2c5d3b3", "value": "fdgsfdg" }, { "questionUuid": "95ddb5b6-1bdc-4e62-820c-6d8a135f5603", "value": "dfsfgsdg" } ] }, { "uuid": "a25f4908-bca2-40c7-8d4c-fefe81ce663c", "answers": [ { "questionUuid": "16a47c7f-707a-4b38-9538-3b38dab07314", "value": "dsadasdsdaa" } ] } ] const getInspectionEditInitialAnswers = (answers) => { return answers.map((answer)=>({[answer.questionUuid]: answer.value})) } const initialValues = answers.reduce((pageMemo, nextPageAnswer) => { if (nextPageAnswer.sections?.length) { return nextPageAnswer.sections.reduce( (sectionMemo, nextSectionAnswer) => ({ ...sectionMemo, [nextSectionAnswer.uuid]: { answers: getInspectionEditInitialAnswers(nextSectionAnswer.answers), }, }), {}, ) } return { ...pageMemo, [nextPageAnswer.uuid]: { answers: getInspectionEditInitialAnswers(nextPageAnswer.answers), }, } }, {})
Map with Object assign
const answers = [ { "uuid": "38913ba2-98fa-48b3-bb2a-ac9d550a1e1a", "answers": [ { "questionUuid": "097707bb-c20d-41a5-8dad-22e2b54dcfd4", "value": "2022-06-04T12:00:00+01:00" }, { "questionUuid": "c6866d6f-dadf-457c-9ef5-4973b2c5d3b3", "value": "fdgsfdg" }, { "questionUuid": "95ddb5b6-1bdc-4e62-820c-6d8a135f5603", "value": "dfsfgsdg" } ] }, { "uuid": "a25f4908-bca2-40c7-8d4c-fefe81ce663c", "answers": [ { "questionUuid": "16a47c7f-707a-4b38-9538-3b38dab07314", "value": "dsadasdsdaa" } ] } ] const getInspectionEditInitialAnswers = (answers) => { return answers.map((answer)=>({[answer.questionUuid]: answer.value})) } const initialValuesMap = answers.map((pageAnswer) => { if (pageAnswer.sections?.length) { return pageAnswer.sections.map( (sectionAnswers) => ({ [sectionAnswers.uuid]: { answers: getInspectionEditInitialAnswers(sectionAnswers.answers), }, }), {}, ) } return { [pageAnswer.uuid]: { answers: getInspectionEditInitialAnswers(pageAnswer.answers), }, } }, {}) const initialValues = Object.assign({}, ...initialValuesMap)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce
Map with Object assign

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:101.0) Gecko/20100101 Firefox/101.0

Browser/OS: Firefox 101 on Windows

View result in a separate tab

Test name	Executions per second
Reduce	1092125.9 Ops/sec
Map with Object assign	724231.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript code is crucial to identify optimization opportunities and improve application performance.

The provided benchmark definition represents two test cases: `Reduce` and `Map with Object.assign`. Both tests aim to measure the performance of transforming an array of objects into a nested object structure.

**Benchmark Definition**

The benchmark definition specifies the following parameters:

*   A JavaScript function that takes an array of objects as input.
*   The function is expected to transform the array into a nested object structure, where each object's `uuid` serves as a key in the resulting object.
*   Two different approaches are compared:
    *   `Reduce`: Using the `reduce()` method to iterate over the array and create the nested object structure.
    *   `Map with Object.assign`: Using the `map()` method followed by `Object.assign()` to achieve the same result.

**Options Compared**

The two options being compared have different performance characteristics:

*   **Reduce**: This approach uses a single iteration over the array, which can be more efficient for large datasets. However, it requires more memory allocation and copying of objects during each iteration.
*   **Map with Object.assign**: This approach involves two iterations: mapping the array into an intermediate object and then using `Object.assign()` to create the final nested object structure. It may require more memory allocations and copies.

**Pros and Cons**

Here's a summary of the pros and cons for each option:

*   **Reduce**
    *   Pros:
        *   Efficient for large datasets due to single iteration.
        *   May be faster in some cases.
    *   Cons:
        *   Requires more memory allocation and copying during each iteration.
        *   Can lead to performance issues with very large datasets or slow JVMs.
*   **Map with Object.assign**
    *   Pros:
        *   Reduces the risk of performance issues due to large dataset sizes, as it breaks the transformation into smaller steps.
        *   Can be more efficient for small to medium-sized arrays, as it minimizes memory allocation and copying overhead.

**Library/Dependencies**

The benchmark uses a library or module that is not explicitly mentioned in the provided code snippet. However, based on the usage of `Object.assign()` and the structure of the nested object, it's likely that a utility library for working with objects (e.g., Lodash) or native JavaScript methods are being used.

**Special JS Features/Syntax**

There are no special JavaScript features or syntaxes mentioned in the benchmark code. The transformations rely solely on standard JavaScript methods like `reduce()`, `map()`, and `Object.assign()`.

**Benchmark Results**

The latest benchmark results show that:

*   Firefox 101 performs better for both test cases.
*   The `Reduce` approach has a higher execution frequency per second compared to the `Map with Object.assign` approach.

Overall, this benchmark highlights the importance of choosing the right algorithmic approach based on the specific requirements and constraints of your application. By understanding the trade-offs between different methods, you can optimize your code for better performance and memory efficiency.

Related benchmarks:

Reduce vs map with Object.assign 1 (version: 1)

Comparing performance of: Reduce vs Map with Object assign

Created: 2 years ago by: Registered User

Jump to the latest result

Reduce

Map with Object assign

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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