Benchmark: Access Object, Map, Set

Script Preparation code:

var keys = [];
var prefix = 'someKeyPrefix';
var obj = {};
var map = new Map();
var set = new Set();

for (var i = 0; i < 300; i++) {
    var key = prefix + i;
    keys.push(key);
    if (i % 3) {
        obj[key] = true;
        map.set(key, true);
        set.add(key);
    }
}

Tests:

Get from Object
for (const key of keys) { var val = obj[key] }
Has key in Object
for (const key of keys) { var has = key in obj }
Get from Map
for (const key of keys) { var val = map.get(key) }
Has key in Map
for (const key of keys) { var has = map.has(key); }
Has key in Set
for (const key of keys) { var has = set.has(key); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Get from Object
Has key in Object
Get from Map
Has key in Map
Has key in Set

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 106 on Windows

View result in a separate tab

Test name	Executions per second
Get from Object	29193.1 Ops/sec
Has key in Object	28236.9 Ops/sec
Get from Map	36934.6 Ops/sec
Has key in Map	37241.9 Ops/sec
Has key in Set	36461.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared options, pros and cons of each approach, and other considerations.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that tests access patterns for different data structures: objects, maps, and sets. The benchmark is designed to measure the performance of iterating over these data structures and checking if a key exists.

**Script Preparation Code**

The script preparation code creates:

1. An empty object (`obj`) and an array of keys (`keys`).
2. A map (`map`) and a set (`set`) with no initial values.
3. A loop that generates 300 keys, prefixes each key with "someKeyPrefix", and adds them to the `keys` array.

**Benchmark Definition**

The benchmark definition consists of six test cases:

1. **Get from Object**: Iterate over `keys` and access the value associated with each key in `obj`.
2. **Has key in Object**: Iterate over `keys` and check if each key exists in `obj` using the `in` operator.
3. **Get from Map**: Iterate over `keys` and retrieve the value associated with each key in `map`.
4. **Has key in Map**: Iterate over `keys` and check if each key exists in `map` using the `has` method.
5. **Has key in Set**: Iterate over `keys` and check if each key exists in `set` using the `has` method.
6. **Get from Object** (again): The same as test case 1, but for map.

**Comparing Options**

The benchmark compares the performance of accessing keys in objects, maps, and sets using different methods:

1. **Object**: Iterating over an array and checking if a key exists using `in`.
2. **Map**: Iterating over an array and retrieving the value associated with each key using the `get` method.
3. **Set**: Iterating over an array and checking if a key exists using the `has` method.

**Pros and Cons**

1. **Object**:
	* Pros: Lightweight, easy to implement.
	* Cons: May be slower than map or set due to hash table lookup overhead.
2. **Map**:
	* Pros: Fast lookups and efficient iteration.
	* Cons: Requires more memory to store the underlying array of keys.
3. **Set**:
	* Pros: Similar performance to map, but with a smaller memory footprint.
	* Cons: May not be suitable for all use cases (e.g., when keys have different types).

**Other Considerations**

1. **Cache Locality**: The benchmark may exhibit cache locality issues due to the sequential access pattern.
2. **Memory Allocation**: The benchmark allocates new objects, maps, and sets on each iteration, which can impact performance.
3. **Browser Variability**: The results may vary across different browsers and versions.

**Alternatives**

If you want to explore alternative approaches or data structures, consider:

1. **Arrays**: Instead of using objects, maps, and sets, use arrays with index-based access.
2. **WeakMaps**: Use `WeakMap` instead of `Map` for faster lookups in JavaScript engines that support them.
3. **Iterators**: Implement your own iterator or use built-in iterators to optimize performance.

Keep in mind that the best approach depends on your specific use case and requirements. Experimenting with different data structures and access patterns can help you find the most efficient solution.

Related benchmarks:

Access Object, Map, Set (version: 0)

Comparing performance of: Get from Object vs Has key in Object vs Get from Map vs Has key in Map vs Has key in Set

Created: 2 years ago by: Registered User

Jump to the latest result

Get from Object

Has key in Object

Get from Map

Has key in Map

Has key in Set

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