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

Script Preparation code:

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

Tests:

Object.hasOwnProperty
Object.prototype.hasOwnProperty.call(object, 'something' + test)
Object in
('something' + test) in object
direct
!!object['something' + test]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.hasOwnProperty
Object in
direct

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 5 days ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this JavaScript microbenchmark.

The benchmark compares the performance of four different approaches to check if a property exists in an object:

1. **`Object.prototype.hasOwnProperty.call(object, 'something' + test)`**: This approach uses the `hasOwnProperty` method to check if the object has a property with the given name. It's a standard way to check for property existence and is widely supported.
2. **`('something' + test) in object`**: This approach uses the `in` operator to check if the property exists in the object. The `in` operator returns a boolean value indicating whether the property is present in the object or not.
3. **`!!object['something' + test]`**: This approach uses a simple coercion to attempt to access the property. If the property exists, the expression will evaluate to `true`, otherwise it will evaluate to `false`. The double exclamation marks (`!!`) are used to force JavaScript to perform a type conversion and then evaluate the result as a boolean.
4. **Direct Coercion**: This approach is simply trying to access the property using bracket notation (`object['something' + test]`). If the property exists, it will return the value; otherwise, it will return `undefined`.

Pros and Cons of each approach:

* **`Object.prototype.hasOwnProperty.call(object, 'something' + test)`**:
	+ Pros: Wide support, efficient, and clear intent.
	+ Cons: Requires accessing the `hasOwnProperty` method on the `Object` prototype, which may incur a small overhead due to prototyping.
* **`('something' + test) in object`**:
	+ Pros: Concise and expressive, doesn't require accessing the `in` operator method.
	+ Cons: May be slower than the other approaches, especially for large objects or complex property names. Some older browsers may not support this approach.
* **`!!object['something' + test]`**:
	+ Pros: Simple and easy to read, can be faster due to the type conversion.
	+ Cons: May lead to unexpected behavior if the property is accessed directly using bracket notation; requires careful consideration of potential edge cases. Also, some older browsers may not support this approach or may have issues with coercion.
* **Direct Coercion**: `object['something' + test]`
	+ Pros: Simple and straightforward, no additional overhead from operator methods.
	+ Cons: May be slower due to the explicit property access; requires careful consideration of potential edge cases, such as when the property is not present or if it's a non-numeric value.

The library being used in this benchmark is none. The test code uses built-in JavaScript features and operators.

As for special JS features or syntax, note that `hasOwnProperty` and `in` are part of the ECMAScript standard, while `!!` coercion is not explicitly mentioned as an issue but may still require consideration due to its behavior in certain situations.

Other alternatives might include using:

* **`object.hasOwnProperty('something' + test)`**: This approach avoids accessing the `hasOwnProperty` method directly and instead calls it on the object's prototype.
* **`Object.keys(object).includes('something' + test)`**: This approach uses the `keys()` method to get an array of property names, then checks if the desired property is present using the `includes()` method.

However, these alternatives might not be as concise or efficient as the original approaches, and may incur additional overhead due to the use of built-in methods.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	2113662.0 Ops/sec
Object in	2768517.0 Ops/sec
direct	2918916.0 Ops/sec

Related benchmarks:

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

Comparing performance of: Object.hasOwnProperty vs Object in vs direct

Created: 2 years ago by: Guest

Jump to the latest result

Object.hasOwnProperty

Object in

direct

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 5 days ago):