Benchmark: Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes v2

Script Preparation code:

  var object = {},
      array = [],
      i, test = 1000;
  
  for (i = 0; i < 1000; i++) {
   object['something' + i] = true;
   array.push('something' + i);
  }

Tests:

Object.hasOwnProperty
object.hasOwnProperty('something' + test)
Object in
('something' + test) in object
Array.indexOf
array.indexOf('something' + test) !== -1
direct
object['something' + test] === true
Array includes
array.includes('something' + test)
Object.prototype.hasOwnProperty.call(this.storeIndex, index)
Object.prototype.hasOwnProperty.call(object, 'something' + test)

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
Object.prototype.hasOwnProperty.call(this.storeIndex, index)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks can be a complex task, and there are various approaches to test the different options. Here's a breakdown of what's being tested, the pros and cons of each approach, and other considerations:

**What is being tested?**

The benchmark tests six different ways to check if an object or array contains a specific value:

1. `object.hasOwnProperty('something' + test)`: checks if the object has a property with the given key.
2. `(something' + test) in object`: uses the `in` operator to check if the object contains the given value.
3. `array.indexOf('something' + test) !== -1`: searches for the value in the array using `indexOf`.
4. `object['something' + test] === true`: checks if the property exists and has a value of `true`.
5. `array.includes('something' + test)`: uses the `includes` method to search for the value in the array.
6. `Object.prototype.hasOwnProperty.call(object, 'something' + test)`: uses a custom `hasOwnProperty` call on the object.

**Approaches and pros/cons:**

1. **`object.hasOwnProperty('something' + test)`**: This approach is often considered the most straightforward way to check if an object has a property.
	* Pros: simple, efficient (no extra iterations).
	* Cons: may be slower than other methods due to the overhead of property lookup.
2. **`(something' + test) in object`**: Using `in` operator can lead to unexpected behavior or false positives if the object's prototype chain is not properly configured.
	* Pros: simple, easy to understand.
	* Cons: may be slower than other methods and less efficient due to property lookup.
3. **`array.indexOf('something' + test) !== -1`**: This approach is generally faster than `in` operator but can lead to false negatives if the array is not properly sorted or if the value is not found within the bounds of the search range.
	* Pros: efficient, fast.
	* Cons: may produce false negatives or unexpected behavior due to edge cases.
4. **`object['something' + test] === true`**: This approach assumes that the property exists and has a value of `true`, which might not always be the case.
	* Pros: simple, easy to understand.
	* Cons: assumes specific property existence and value, may lead to false positives or unexpected behavior.
5. **`array.includes('something' + test)`**: This approach is generally faster than other methods but can lead to false negatives if the array is not properly sorted or if the value is not found within the bounds of the search range.
	* Pros: efficient, fast.
	* Cons: may produce false negatives or unexpected behavior due to edge cases.
6. **`Object.prototype.hasOwnProperty.call(object, 'something' + test)`**: This approach uses a custom `hasOwnProperty` call on the object's prototype chain.
	* Pros: provides more control over property lookup and handling edge cases.
	* Cons: may lead to performance issues or unexpected behavior if not used carefully.

**Other considerations:**

* The benchmark results show that Chrome 99, running on Linux desktop, produces the highest execution rate for each test case. Other browsers and platforms may produce different results due to varying optimizations and interpretations of the JavaScript engine.
* The `includes` method is generally faster than other approaches but can lead to false negatives or unexpected behavior if not used carefully.

**Alternatives:**

Other alternatives to these approaches include:

* Using a library like Lodash, which provides utility functions for working with objects and arrays.
* Implementing custom lookup methods using bitwise operations (e.g., using the `&` operator to check for property existence).
* Utilizing modern JavaScript features like `Map`, `WeakMap`, or `Set` data structures for efficient property storage and lookup.

Keep in mind that these alternatives may introduce additional complexity, dependencies, or performance overhead, so it's essential to consider the trade-offs when choosing an approach.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.16 Safari/537.36

Browser/OS: Chrome 99 on Linux

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	3136243.0 Ops/sec
Object in	2864621.0 Ops/sec
Array.indexOf	854761.6 Ops/sec
direct	2887668.8 Ops/sec
Array includes	860361.2 Ops/sec
Object.prototype.hasOwnProperty.call(this.storeIndex, index)	1823277.8 Ops/sec

Related benchmarks:

Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes v2 (version: 0)

Comparing performance of: Object.hasOwnProperty vs Object in vs Array.indexOf vs direct vs Array includes vs Object.prototype.hasOwnProperty.call(this.storeIndex, index)

Created: 3 years ago by: Guest

Jump to the latest result

Object.hasOwnProperty

Object in

Array.indexOf

direct

Array includes

Object.prototype.hasOwnProperty.call(this.storeIndex, index)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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