Benchmark: Map vs Object - string keys - read performance

Script Preparation code:

window.myMap = new Map();
window.myObj = new Map();
window.generateObj = () => ({
    'a': Math.random() * 10000,
    'b': Math.random() * 10000,
    'c': Math.random() * 10000
});

for (let i = 0; i < 1000; i++) {
    let id = 'id-' + i;
    let obj = generateObj();
    myMap.set(id, obj);
    myObj[id] = obj;
}

Tests:

Read from map
let id = `id-` + Math.floor(Math.random() * 1000); let value = myMap.get(id);
Read from obj
let id = `id-` + Math.floor(Math.random() * 1000); let value = myObj[id];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Read from map
Read from obj

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of reading values from two data structures: `Map` and `Object`. Both data structures are created with string keys, but they differ in how the keys are generated. The key generation is done using template literals (`id-` + random number).

**Options Compared**

There are two options compared:

1. **Reading from a Map**: The benchmark defines a function `generateObj()` that returns an object with three properties (key-value pairs). This object is then set on the `Map` instance using the generated key.
2. **Reading from an Object**: The same `generateObj()` function is used, but its return value is assigned directly to the `Object` instance using the generated key.

**Pros and Cons of Each Approach**

**Map**

Pros:

* Maps are designed for fast lookups, especially when keys are unique.
* Template literals can be more readable and efficient than concatenation.

Cons:

* Maps require a specific type of key (string) to be used as a key.
* If the key is not present in the map, `get()` returns `undefined`.

**Object**

Pros:

* Objects allow for any data type as keys, making them more flexible.
* Assigning values to an object using a key-value pair syntax can be easier to read.

Cons:

* Objects are generally slower than maps when it comes to lookups.
* Using template literals may lead to performance issues if the browser doesn't optimize them correctly.

**Library and Special JS Features**

The `Map` and `Object` instances are part of the JavaScript standard library. No special libraries or features are used in this benchmark.

**Other Considerations**

This benchmark is likely intended to test the performance differences between maps and objects when it comes to fast lookups. The use of template literals and random key generation adds an extra layer of complexity, making it a more challenging benchmark.

If you want to simulate similar scenarios, you can create additional benchmark definitions with different options (e.g., reading from arrays or sets) to test the performance of various JavaScript data structures.

Other alternatives for measuring performance in JavaScript benchmarks include:

* Using `Date.now()` and manual timing loops.
* Leveraging existing libraries like Benchmark.js or PerfTest.
* Creating custom timers using Web APIs like `performance.now()` or `requestAnimationFrame()`.
* Utilizing framework-specific performance testing tools, such as React's `react-dom/test-utils` or Angular's `@angular/core/testing`.

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 92 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Read from map	1749678.5 Ops/sec
Read from obj	1403757.0 Ops/sec

Related benchmarks:

Map vs Object - string keys - read performance (version: 0)

Comparing performance of: Read from map vs Read from obj

Created: 3 years ago by: Guest

Jump to the latest result

Read from map

Read from obj

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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