Benchmark: Test if key is in object.

Script Preparation code:

var entries = new Array(1000).fill(0).map((_, i) => ['id_'+i, true]);
var obj = Object.fromEntries(entries);
var map = new Map(entries);

Tests:

Lookup Map
let hasKey = map.has('id_900');
Object dot
let hasKey = !!obj['id_900'];
Object in
let hasKey = 'id_900' in obj;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lookup Map
Object dot
Object in

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is tested, the options compared, their pros and cons, and other considerations.

**Benchmark Overview**

The benchmark measures the performance of three different ways to check if a key exists in an object or map:

1. **Lookup Map**: Using the `has()` method on a `Map` object.
2. **Object dot**: Using the property access syntax (`obj['id_900']`) to access the value associated with the key `'id_900'`.
3. **Object in**: Using the `in` operator (`'id_900' in obj`) to check if the key exists in the object.

**Script Preparation Code**

The script preparation code creates a large array of key-value pairs, converts it into an `Array` and then an `Object`, and finally into a `Map`. This allows us to test each method on different data structures (array, object, and map).

```javascript
var entries = new Array(1000).fill(0).map((_, i) => ['id_'+i, true]);
var obj = Object.fromEntries(entries);
var map = new Map(entries);
```

**Options Compared**

The three options compared are:

1. **Lookup Map**: Using `has()` method on a `Map` object.
	* Pros: Fast and efficient for large maps.
	* Cons: May not work as expected for non-map objects, may be slower for small maps due to map overhead.
2. **Object dot**: Using property access syntax (`obj['id_900']`) to access the value associated with the key `'id_900'`.
	* Pros: Fast and efficient for objects.
	* Cons: May not work as expected if the key is not a string, may be slower for very large objects due to property lookup overhead.
3. **Object in**: Using the `in` operator (`'id_900' in obj`) to check if the key exists in the object.
	* Pros: Fast and efficient for objects.
	* Cons: May have performance issues with large objects, may not work as expected with non-object data structures.

**Library Used**

No external library is used in this benchmark. The `Map` class and the `Object.fromEntries()` method are built-in JavaScript features.

**Special JS Feature/Syntax**

The benchmark uses the following special syntax:

* **Object from Entries**: The `Object.fromEntries()` method was introduced in ECMAScript 2015 (ES6). It allows creating an object from an array of key-value pairs.
* **Map**: The `Map` class is a built-in JavaScript feature that allows creating a map data structure.

**Other Considerations**

When measuring performance, it's essential to consider factors like:

* Cache locality: How does the method behave when executing multiple iterations with similar input?
* Branch prediction: Does the method use conditional statements that can affect branch prediction?
* Interpreter vs. compiler optimizations: Are there any differences in performance between interpreted and compiled code?

**Alternatives**

If you're looking for alternatives to this benchmark, consider:

* **Array methods**: Using `indexOf()` or `includes()` on an array instead of a map.
* **Object methods**: Using `in` operator with object literals instead of property access syntax.
* **Native methods**: Using native methods like `get()` and `has()` on DOM elements instead of JavaScript objects.

Keep in mind that the performance differences between these alternatives may be negligible or non-existent, depending on the specific use case and browser implementation.

Related benchmarks:

Test if key is in object. (version: 0)

Comparing performance of: Lookup Map vs Object dot vs Object in

Created: 3 years ago by: Guest

Jump to the latest result

Lookup Map

Object dot

Object in

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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