Benchmark: Merge resources: Object.map

Script Preparation code:

const SIZE = 1000
const RESOURCE_TYPES = [...Array(SIZE).fill().keys()] // 0..100
const object1 = [...Array(SIZE * .5).fill().keys()].reduce((res, idx) => ({...res, [idx + SIZE * .5]: 1}), {}) // 0..49 = undefined, 50..99 = 1
const object2 = [...Array(SIZE).fill().keys()].filter(x => x % 2).reduce((res, idx) => ({...res, [idx]: 1}), {}) // 1,3,5..97,99 = 1
const map1 = new Map(Object.keys(object1).map(k => ([+k, object1[k]])))
const map2 = new Map(Object.keys(object2).map(k => ([+k, object2[k]])))
window.DATA = {
  RESOURCE_TYPES, object1, object2, map1, map2
}

Tests:

RESOURCE_TYPES + ...res
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA RESOURCE_TYPES.reduce((res, type) => { return { ...res, [type]: (object1[type] ?? 0) + (object2[type] ?? 0) } }, object1)
RESOURCE_TYPES + res[type]
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA RESOURCE_TYPES.reduce((res, type) => { res[type] = (object1[type] ?? 0) + (object2[type] ?? 0) return res }, object1)
RESOURCE_TYPES.map
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA RESOURCE_TYPES.map((type) => { object1[type] = (object1[type] ?? 0) + (object2[type] ?? 0) })
RESOURCE_TYPES.forEach
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA RESOURCE_TYPES.forEach((type) => { object1[type] = (object1[type] ?? 0) + (object2[type] ?? 0) })
RESOURCE_TYPES for of
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA for (const type of RESOURCE_TYPES) { object1[type] = (object1[type] ?? 0) + (object2[type] ?? 0) }
RESOURCE_TYPES for let i
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA for (let i = 0; i < RESOURCE_TYPES.length; ++i) { const type = RESOURCE_TYPES[i] object1[type] = (object1[type] ?? 0) + (object2[type] ?? 0) }
RESOURCE_TYPES + Map
const {RESOURCE_TYPES, object1, object2, map1, map2} = window.DATA RESOURCE_TYPES.forEach((type) => { map1.set(type, (map1.get(type) ?? 0) + (map2.get(type) ?? 0)) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RESOURCE_TYPES + ...res
RESOURCE_TYPES + res[type]
RESOURCE_TYPES.map
RESOURCE_TYPES.forEach
RESOURCE_TYPES for of
RESOURCE_TYPES for let i
RESOURCE_TYPES + Map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
RESOURCE_TYPES + ...res	2535.3 Ops/sec
RESOURCE_TYPES + res[type]	127490.3 Ops/sec
RESOURCE_TYPES.map	177083.9 Ops/sec
RESOURCE_TYPES.forEach	252779.1 Ops/sec
RESOURCE_TYPES for of	94039.4 Ops/sec
RESOURCE_TYPES for let i	288608.2 Ops/sec
RESOURCE_TYPES + Map	31617.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark is defined in two parts: Script Preparation Code and Html Preparation Code. However, only the Script Preparation Code is relevant to the individual test cases.

Script Preparation Code:
```javascript
const SIZE = 1000;
const RESOURCE_TYPES = [...Array(SIZE).fill().keys()];
const object1 = [...Array(SIZE * .5).fill().keys()].reduce((res, idx) => ({...res, [idx + SIZE * .5]: 1}), {});
const object2 = [...Array(SIZE).fill().keys()].filter(x => x % 2).reduce((res, idx) => ({...res, [idx]: 1}), {});
const map1 = new Map(Object.keys(object1).map(k => ([+k, object1[k]])));
const map2 = new Map(Object.keys(object2).map(k => ([+k, object2[k]])));
window.DATA = {RESOURCE_TYPES, object1, object2, map1, map2};
```
This code creates:

* `RESOURCE_TYPES`: an array of 1000 numbers from 0 to 999.
* `object1` and `object2`: two objects with keys and values that are used for later tests.
* `map1` and `map2`: two maps created from the objects.

**Individual Test Cases**

The individual test cases are defined in an array:
```javascript
[
    {
        "RawUAString": "...",
        "Browser": "Chrome 126",
        "DevicePlatform": "Desktop",
        "OperatingSystem": "Windows",
        "ExecutionsPerSecond": ...,
        "TestName": "RESOURCE_TYPES for let i"
    },
    // ...
]
```
Each test case has a unique name that corresponds to one of the following methods:

* `RESOURCE_TYPES + res[type]`: accesses an object property using bracket notation (`object1[0]`, `object2[1]`, etc.)
* `RESOURCE_TYPES for let i`: iterates over the array using a `for...of` loop
* `RESOURCE_TYPES forEach`: iterates over the array using the `forEach` method
* `RESOURCE_TYPES map`: uses the `map` function to create a new array
* `RESOURCE_TYPES ...res`: accesses an object property using spread operator (`object1[0]`, `object2[1]`, etc.)

**What is being tested?**

The benchmark is testing the performance of different methods for accessing and manipulating arrays, objects, and maps. The test cases are comparing the execution speed of each method.

In this specific case, the results show that:

* `RESOURCE_TYPES for let i` is the fastest (around 177,000 executions per second).
* `RESOURCE_TYPES forEach` is slightly slower (around 252,779 executions per second).
* `RESOURCE_TYPES map` is slower still (around 127,490 executions per second).
* Accessing object properties using bracket notation (`...res`) and spread operator (`...res`) are the slowest (around 94039 and 2535 executions per second, respectively).

These results suggest that iterating over arrays or objects using `for...of` loops or `forEach` methods is generally faster than accessing individual elements using bracket notation or spread operator.

Related benchmarks:

Merge resources: Object.map (version: 0)

map

Comparing performance of: RESOURCE_TYPES + ...res vs RESOURCE_TYPES + res[type] vs RESOURCE_TYPES.map vs RESOURCE_TYPES.forEach vs RESOURCE_TYPES for of vs RESOURCE_TYPES for let i vs RESOURCE_TYPES + Map

Created: 5 months ago by: Guest

Jump to the latest result

RESOURCE_TYPES + ...res

RESOURCE_TYPES + res[type]

RESOURCE_TYPES.map

RESOURCE_TYPES.forEach

RESOURCE_TYPES for of

RESOURCE_TYPES for let i

RESOURCE_TYPES + Map

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