Benchmark: Map vs Object - string keys - write performance

Script Preparation code:

window.myObj = {};
window.myMap = new Map();
window.generateId = () => new Date().toISOString() + '=' + Math.random();
window.generateObj = () => ({
    'a': generateId(),
    'b': generateId(),
    'c': generateId()
});

Tests:

Write to map
myMap.set(generateId(), generateObj());
Write to obj
myObj[generateId()] = generateObj();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Write to map
Write to obj

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Test name	Executions per second
Write to map	188731.9 Ops/sec
Write to obj	188330.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The provided JSON represents a benchmark test case, which compares two approaches for writing data to objects in JavaScript: using a `Map` (a built-in JavaScript object) versus using an ordinary object (`Object`). The test measures the performance difference between these two approaches when writing a string key and a value to each data structure.

**Options being compared**

There are only two options being compared:

1. **Using a Map**: This approach uses the `Map` object, which is a built-in JavaScript object that stores key-value pairs in a way that allows for efficient lookups, insertions, and deletions.
2. **Using an ordinary Object**: This approach uses a regular object (i.e., an instance of `Object`) to store key-value pairs.

**Pros and Cons**

* Using a Map:
	+ Pros: Maps are designed for fast lookups and insertions, making them suitable for applications where data is frequently added or updated. They also provide features like `forEach`, `entries`, and `keys` methods.
	+ Cons: Maps are less intuitive to use than ordinary objects, especially when working with string keys.
* Using an ordinary Object:
	+ Pros: Ordinary objects are more familiar to developers, making them easier to understand and work with. They also support features like inheritance and prototypal inheritance.
	+ Cons: Ordinary objects can be slower than Maps for large datasets or frequent lookups, as they rely on hash tables which can lead to collisions.

**Other considerations**

* **String key vs. numerical key**: The test only uses string keys, but using numerical keys could provide better performance and cacheability in certain scenarios.
* **Data structure size**: The test only creates a single value (`generateObj()`) for each write operation. Adding more data would impact the performance difference between Maps and ordinary objects.

**Library usage**

There is no explicit library usage mentioned in the benchmark definition or test cases. However, JavaScript engines like V8 (used by Chrome) and SpiderMonkey (used by Firefox) provide built-in support for Maps and other data structures.

**Special JS feature/syntax**

There are a few features used in this benchmark:

* **Arrow functions**: The `generateId` and `generateObj` functions use arrow functions, which are a shorthand way of defining small, one-time-use functions.
* **String interpolation**: The `generateId` function uses string interpolation (`+='= '+`) to concatenate strings with other values.

**Other alternatives**

If you want to compare the performance of different data structures or approaches, consider using alternative options like:

* Using a `Set` instead of an object for fast membership testing.
* Implementing your own hash table or data structure from scratch.
* Using a library like Lodash (which provides utility functions for working with objects and arrays).
* Creating a custom JavaScript engine or optimizing existing engines for specific use cases.

Related benchmarks:

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

Comparing performance of: Write to map vs Write to obj

Created: 4 years ago by: Guest

Jump to the latest result

Write to map

Write to obj

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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