Benchmark: random Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes vs Set.has

Script Preparation code:

var object = {},
    array = [],
    set = new Set();
let i;
  
for (i = 0; i < 1000; i++) {
    object['something' + i] = true;
    array.push('something' + i);
    set.add('something' + i);
}

Tests:

Object.hasOwnProperty
object.hasOwnProperty('something' + Math.floor(Math.random() * 1000))
Object in
('something' + Math.floor(Math.random() * 1000)) in object
Array.indexOf
array.indexOf('something' + Math.floor(Math.random() * 1000)) !== -1
direct
object['something' + Math.floor(Math.random() * 1000)]
Array includes
array.includes('something' + Math.floor(Math.random() * 1000))
Set has
set.has('something' + Math.floor(Math.random() * 1000))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.hasOwnProperty
Object in
Array.indexOf
direct
Array includes
Set has

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 92 on Windows

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	1543042.4 Ops/sec
Object in	1357842.9 Ops/sec
Array.indexOf	225389.0 Ops/sec
direct	1729548.6 Ops/sec
Array includes	217106.8 Ops/sec
Set has	1822450.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net, comparing the performance of different approaches to check if an object has a specific property or value.

**Benchmark Definition**

The benchmark definition is created by preparing a script that generates 1000 random objects with properties named "something" followed by a unique identifier (a number between 0 and 999). The script then uses each of six different methods to access these properties:

1. `object.hasOwnProperty('something' + Math.floor(Math.random() * 1000))`: This method checks if the object has a property with the given key.
2. `( 'something' + Math.floor(Math.random() * 1000) ) in object`: This method uses the `in` operator to check if the object has a property with the given key.
3. `array.indexOf('something' + Math.floor(Math.random() * 1000)) !== -1`: This method checks if an array contains an element that matches the given value.
4. `object['something' + Math.floor(Math.random() * 1000)]`: This method directly accesses the property using bracket notation.
5. `array.includes('something' + Math.floor(Math.random() * 1000))`: This method uses the `includes` method to check if an array contains an element that matches the given value.
6. `set.has('something' + Math.floor(Math.random() * 1000))`: This method checks if a Set object has a specific element.

**Comparison of Methods**

The comparison involves executing each method a large number of times (1 million) and measuring the execution time per second. The results show that:

* `Set.has` is the fastest, with an average of around 200,000 executions per second.
* Directly accessing the property using bracket notation (`object['something' + Math.floor(Math.random() * 1000)]`) is faster than using the `in` operator or `hasOwnProperty` methods, but slower than `Set.has`.
* Checking if an array contains a specific value using `indexOf` or `includes` is relatively slow, with an average of around 150,000 executions per second.
* Using the `in` operator to check if an object has a property is slower than checking directly (`object.hasOwnProperty`) or using `Set.has`.

**Pros and Cons**

The pros and cons of each method are:

* **Set.has**: Fast, reliable, and efficient. Cons: Requires a Set object, which may not be present in all situations.
* **Directly accessing the property**: Fast and convenient, but may not work for all types of objects or properties. Cons: May lead to errors if the property is not present or does not exist.
* **In** operator: Relatively fast, but may not work correctly with some types of objects or properties. Cons: Less reliable than `Set.has` or direct access.
* **hasOwnProperty**: Similar to `in`, but more specific and reliable. Pros: More precise control over the check, but slower than `Set.has`.
* **indexOf** and **includes**: Relatively slow, especially for large arrays. Cons: May lead to errors if the value is not present in the array.

**Other Considerations**

When choosing a method, consider the following factors:

* **Performance**: If speed is critical, use `Set.has` or direct access.
* **Reliability**: If accuracy is paramount, use `hasOwnProperty` or check directly (`object.hasOwnProperty`).
* **Convenience**: Use the most convenient method that still meets your requirements.

**Alternatives**

Other alternatives to these methods include:

* Using a Map object instead of an object literal
* Using a regular expression to search for the property name
* Implementing a custom lookup mechanism

Keep in mind that these alternatives may have different performance characteristics and trade-offs, depending on the specific use case.

Related benchmarks:

random Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes vs Set.has (version: 0)

Comparing performance of: Object.hasOwnProperty vs Object in vs Array.indexOf vs direct vs Array includes vs Set has

Created: 3 years ago by: Registered User

Jump to the latest result

Object.hasOwnProperty

Object in

Array.indexOf

direct

Array includes

Set has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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