Benchmark: array of objects to object

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; }, {});

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its components.

**Benchmark Definition**

The benchmark is testing the performance of three different approaches to reduce an array of objects into a single object. The reduction operation takes an initial value (in this case, an empty object `{}`) and iterates through each element in the `parts` array, applying a transformation function to each element.

The transformation function takes an object with two properties: `type` and `value`. Based on the `type`, the function updates the resulting object accordingly. The three approaches differ in how they handle the assignment of values to the resulting object.

**Approach 1: Spread Operator (`reduce` with spread)**

```javascript
parts.reduce((result, { type, value }) => ({ ...result, [type]: value }), {});
```

This approach uses the spread operator (`{ ...result, [type]: value }`) to create a new object and assign values to it. The resulting object is then returned by the transformation function.

Pros:

* Concise and expressive syntax
* Easy to read and maintain

Cons:

* May incur additional overhead due to the creation of a new object on each iteration

**Approach 2: Direct Assignment (`reduce` with assign)**

```javascript
parts.reduce((result, { type, value }) => {
  result[type] = value;
  return result;
}, {});
```

This approach uses direct assignment to update the `result` object. The transformation function returns the updated object.

Pros:

* Efficient use of memory since no new objects are created

Cons:

* May be less readable and maintainable due to the lack of explicit object creation

**Approach 3: Switch Statement (`reduce` with mapped assign)**

```javascript
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;
}, {});
```

This approach uses a switch statement to handle different types of values. The transformation function returns the updated object.

Pros:

* Can provide additional benefits such as caching or memoization for specific cases

Cons:

* May be less efficient and more complex due to the use of a switch statement

**Libraries and Special Features**

The benchmark definition uses JavaScript, but no specific libraries are mentioned. However, it's worth noting that some modern JavaScript engines may have features like `let` and `const` hoisting or ES6 module syntax.

**Other Alternatives**

Some alternative approaches to reduce an array of objects into a single object might include:

* Using the `Object.assign()` method
* Utilizing a library like Lodash's `_.assignIn()` function
* Employing a custom implementation using a data structure like a Map or a trie

Keep in mind that the choice of approach depends on the specific requirements and constraints of the project.

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	1538155.1 Ops/sec
reduce with assign	8253065.0 Ops/sec
reduce with mapped assign	15577807.0 Ops/sec

Related benchmarks:

array of objects to object (version: 0)

Comparing performance of: reduce with spread vs reduce with assign vs reduce with mapped assign

Created: one year ago by: Guest

Jump to the latest result

reduce with spread

reduce with assign

reduce with mapped assign

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