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

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)

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

The benchmark compares the performance of different methods for checking if a key exists in an object:

1. `object.hasOwnProperty('something' + test)`
2. `( 'something' + test ) in object`
3. `array.indexOf('something' + test) !== -1`
4. `object['something' + test] === true` (referred to as "direct")
5. `array.includes('something' + test)`

**Methods Comparison**

Here's a brief description of each method:

1. **`object.hasOwnProperty('something' + test)`**: This method checks if the property `'something' + test` exists in the object using the `hasOwnProperty()` method. It returns a boolean value indicating whether the property is an own property (i.e., not inherited from another object).
2. **`( 'something' + test ) in object`**: This method uses the `in` operator to check if the string `'something' + test` exists as a key in the object.
3. **`array.indexOf('something' + test) !== -1`**: This method searches for the string `'something' + test` in the array using the `indexOf()` method and checks if it's not equal to `-1`, indicating the presence of the element.
4. **`object['something' + test] === true` (direct)**: This method directly accesses the property `'something' + test` on the object and compares its value with `true`.
5. **`array.includes('something' + test)`**: This method uses the `includes()` method to check if the string `'something' + test` is an element of the array.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **`object.hasOwnProperty('something' + test')`**:
	* Pros: Simple, efficient, and well-supported by most browsers.
	* Cons: May not be supported in older browsers or Internet Explorer.
2. **`( 'something' + test ) in object`**:
	* Pros: Easy to read, well-supported by modern browsers.
	* Cons: Can lead to slower performance due to string lookup.
3. **`array.indexOf('something' + test) !== -1`**:
	* Pros: Fast and efficient for array searches.
	* Cons: May not be supported in older browsers or Internet Explorer.
4. **`object['something' + test] === true (direct)`**:
	* Pros: Simple, efficient, and well-supported by most browsers.
	* Cons: Can lead to slower performance due to property lookup.
5. **`array.includes('something' + test)`**:
	* Pros: Easy to read, fast, and well-supported by modern browsers.
	* Cons: May not be supported in older browsers or Internet Explorer.

**Library Usage**

There is no explicit library usage mentioned in the benchmark code. However, the `includes()` method on arrays uses a proprietary algorithm implemented in WebKit (Chrome's rendering engine) that may not be fully compatible with other browsers.

**Special JS Features or Syntax**

No special JavaScript features or syntax are used in this benchmark. The code is relatively straightforward and uses standard JavaScript constructs.

**Alternatives**

If you're interested in exploring alternative methods, here are a few:

* For `object.hasOwnProperty('something' + test)`:
	+ `in` operator with a proxy object to avoid inheritance issues.
	+ Using the `Symbol.has()` method (available in modern browsers).
* For `( 'something' + test ) in object`:
	+ Using the `Object.keys()` and `Array.prototype.includes()` methods for faster lookup.
	+ Implementing a custom string lookup algorithm using bitwise operations or regular expressions.
* For `array.indexOf('something' + test) !== -1`:
	+ Using the `Array.prototype.findIndex()` method (available in modern browsers).
	+ Implementing a custom search algorithm using bitwise operations or regular expressions.

Please note that some of these alternatives may have performance implications, compatibility issues, or require additional code complexity.

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	9388673.0 Ops/sec
Object in	8686708.0 Ops/sec
Array.indexOf	1537453.9 Ops/sec
direct	8639124.0 Ops/sec
Array includes	1533743.2 Ops/sec

Related benchmarks:

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

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

Created: 7 years ago by: Guest

Jump to the latest result

Object.hasOwnProperty

Object in

Array.indexOf

direct

Array includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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