Benchmark: map vs object - key access (string key)

Script Preparation code:

var items = Array.from(Array(1000), (_, x) => ({
    key: "abcd"+x,
    value: x * 10
}));

var objContainer = {};
var mapContainer = new Map();

for (let i = 100; i >= 0; i--) {
    const index = Math.floor(Math.random() * 1000);
    const item = items[index];
    objContainer[item.key] = item;
    mapContainer.set(item.key, item)
}

Tests:

Object access
items.forEach(item => objContainer[item.value])
Map get
items.forEach(item => mapContainer.get(item.value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object access
Map get

Fastest: N/A

Slowest: N/A

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/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object access	30271.8 Ops/sec
Map get	29266.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON for MeasureThat.net, which is used to create and run JavaScript microbenchmarks.

**Benchmark Definition:**

The benchmark tests two approaches to access data in an object or map:

1. **Object Access**: The script iterates over an array of objects (`items`) using `forEach`, and then accesses each object's value using the dot notation (`objContainer[item.value]`).
2. **Map Get**: The script iterates over the same array of objects (`items`) using `forEach`, and then retrieves a value from the map using the `get()` method (`mapContainer.get(item.value)`).

**Comparison:**

The benchmark compares the performance of accessing data in an object versus a map. Specifically, it measures the time taken to iterate over the items and access their values in both approaches.

**Pros and Cons:**

* **Object Access**: Pros:
	+ Easy to implement and understand.
	+ Typically faster for small to medium-sized datasets.
Cons:
	+ May be slower for large datasets due to the need to iterate over all elements.
* **Map Get**: Pros:
	+ Optimized for fast lookups, making it suitable for large datasets.
Cons:
	+ Requires a map data structure, which can be more complex to implement and understand.

**Library and Syntax:**

In both test cases, the `Array.from()` method is used to create an array of objects. The `Map` object is used in the second test case.

The `forEach()` method is used to iterate over the arrays and maps. There are no special JavaScript features or syntaxes being tested here.

**Other Alternatives:**

If you wanted to write this benchmark using a different approach, here are some alternatives:

1. Use a more efficient data structure, such as a sparse array or an object with a specific key.
2. Use a library like Lodash or Underscore.js to simplify the iteration and lookup processes.
3. Test other access patterns, such as using `Object.keys()` or `map.values()`.
4. Increase the dataset size to see how the performance differences between object and map access hold up.

Keep in mind that these alternatives would require modifications to the benchmark script and might not provide a fair comparison with MeasureThat.net's existing implementation.

Related benchmarks:

map vs object - key access (string key) (version: 0)

Comparing performance of: Object access vs Map get

Created: 3 years ago by: Guest

Jump to the latest result

Object access

Map get

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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