Benchmark: array of objects to object v3

HTML Preparation code:

<script>
const parts = [{
        "type": "currency",
        "value": "€"
    },
    {
        "type": "integer",
        "value": "1"
    },
    {
        "type": "group",
        "value": ","
    },
    {
        "type": "integer",
        "value": "000"
    },
    {
        "type": "decimal",
        "value": "."
    },
    {
        "type": "fraction",
        "value": "00"
    }
]
</script>

Tests:

reduce with spread
parts.reduce((result, { type, value }) => ({ ...result, [type]: value }), {});
reduce with assign
parts.reduce((result, { type, value }) => { result[type] = value; return result; }, {});
reduce with mapped assign
parts.reduce((result, { type, value }) => { switch (type) { case 'currency': result.currencySign = value; break; case 'decimal': result.decimalSeparator = value; break; case 'group': result.thousandSeparator = value; break; default: break; } return result; }, {});
reduce with mapped assign (compact)
const METADATA = { currency: 'currencySign', decimal: 'decimalSeparator', group: 'thousandSeparator', }; parts.reduce((result, { type, value }) => { if (METADATA[type]) result[METADATA[type]] = value; return result; }, {});
reduce with mapped assign (if-else)
parts.reduce((result, { type, value }) => { if (type === 'currency') result.currencySign = value else if (type === 'decimal') result.decimalSeparator = value else if (type === 'group') result.thousandSeparator = value return result; }, {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce with spread
reduce with assign
reduce with mapped assign
reduce with mapped assign (compact)
reduce with mapped assign (if-else)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a benchmark test case for measuring the performance of JavaScript's `Array.prototype.reduce()` method when used to transform an array of objects into an object.

**What is being tested?**

Three different approaches are compared:

1. **Reduce with spread**: The original implementation using the spread operator (`{ ...result, [type]: value }`).
2. **Reduce with assign**: A modified implementation that assigns values directly to object properties (`result[type] = value;`).
3. **Reduce with mapped assign (if-else)**: Another modified implementation that uses an if-else statement to assign values based on the `type` property.
4. **Reduce with mapped assign (compact)**: A compact version of the previous implementation, which eliminates unnecessary nesting.

**Options comparison**

Each approach has its pros and cons:

* **Reduce with spread**: This is a concise and efficient way to transform the array into an object. However, it may not be as readable or maintainable for complex transformations.
* **Reduce with assign**: This approach is more explicit about assigning values, making it easier to understand and debug. However, it may be slower due to the overhead of object property assignments.
* **Reduce with mapped assign (if-else)**: This implementation uses a more traditional if-else statement, which can make it harder to read and maintain for complex transformations. However, it provides better control over the assignment process.
* **Reduce with mapped assign (compact)**: This compact version eliminates unnecessary nesting, making it more efficient and easier to read.

**Library usage**

The `parts` array is used as a sample data set in each test case. It represents an array of objects with different types (`currency`, `integer`, `group`, `decimal`, and `fraction`). The library being used here is the JavaScript standard library, specifically the `Array.prototype.reduce()` method.

**Special JS feature or syntax**

None of the provided implementations use any special JavaScript features or syntax. They are all straightforward implementations of the `reduce()` method.

**Alternatives**

Other alternatives for transforming arrays into objects using JavaScript include:

* Using a `forEach` loop with an object literal (`result = {}; result.forEach((part) => ({ ...result, [part.type]: part.value }));`)
* Utilizing a library like Lodash's `mapObject()` function
* Implementing a custom transformation function using recursion or iteration

Keep in mind that each approach has its trade-offs and use cases. The choice of implementation depends on the specific requirements and performance characteristics of the application.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 115 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce with spread	1533503.9 Ops/sec
reduce with assign	8200524.0 Ops/sec
reduce with mapped assign	15384807.0 Ops/sec
reduce with mapped assign (compact)	6749741.5 Ops/sec
reduce with mapped assign (if-else)	15363904.0 Ops/sec

Related benchmarks:

array of objects to object v3 (version: 0)

Comparing performance of: reduce with spread vs reduce with assign vs reduce with mapped assign vs reduce with mapped assign (compact) vs reduce with mapped assign (if-else)

Created: one year ago by: Guest

Jump to the latest result

reduce with spread

reduce with assign

reduce with mapped assign

reduce with mapped assign (compact)

reduce with mapped assign (if-else)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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