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

Script Preparation code:

  var object = {},
      array = [],
      i, test = 1000000
  
  for (i = 0; i < 1000000; 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 28 days ago):

LLMs can make mistakes. Check important info.

I'd be happy to help break down the benchmark and explain what's being tested.

**Overview**

The provided JSON defines a JavaScript microbenchmark that compares the performance of different methods for checking if an object has a specific property or value:

* `Object.hasOwnProperty`
* `Object in`
* `Array.indexOf`
* `Array.includes`

To make things more challenging, all tests are executed 1 million times (`test = 1000000`) with a large number of properties (keys) on the object and array.

**Test Cases**

Each test case has a unique "Benchmark Definition" string that specifies how to execute the test. Let's break down each one:

1. `object.hasOwnProperty('something' + test)`: This tests the `hasOwnProperty` method, which returns `true` if the specified property exists on the object.
2. `( 'something' + test ) in object`: This uses the "in" operator to check if the property exists on the object. The expression `('something' + test)` creates a new string by concatenating `'something'` with the current iteration number (`test`).
3. `array.indexOf('something' + test) !== -1`: This tests the `indexOf` method, which returns the index of the first occurrence of the specified value in the array. The expression `( 'something' + test )` is used as the search value.
4. `object['something' + test] === true`: This uses direct property access to check if the value at the property key exists on the object.
5. `array.includes('something' + test)`: This tests the `includes` method, which returns `true` if the specified value is present in the array.

**Performance Comparison**

The benchmark results show the performance of each method across multiple browser and device configurations. The results are measured in executions per second (`ExecutionsPerSecond`) for each test case.

From these results, we can observe that:

* `Object.hasOwnProperty` appears to be the fastest method, followed closely by direct property access (`object['something' + test] === true`). These two methods likely have optimal caching and lookup behaviors.
* The "in" operator is slower than the other two methods, possibly due to its dynamic nature and potential overhead from checking if the property exists on the object's prototype chain.
* `Array.indexOf` is slower than expected, potentially due to the need to search through the array's elements. However, this result might be influenced by browser optimizations or caching.
* `Array.includes` is relatively fast, possibly because it leverages a similar cache and lookup mechanism as `Object.hasOwnProperty`.

**Libraries and Special Features**

None of the tests explicitly use any external libraries. However, some browsers might have native support for these methods or built-in caching mechanisms that affect their performance.

No special JavaScript features are used in this benchmark, apart from the implicit usage of ES6 template literals (e.g., `('something' + test)`).

**Alternatives**

If you're interested in exploring alternative approaches, consider the following:

* For direct property access (`object['something' + test] === true`), using a Map or WeakMap instead might provide better performance and caching.
* For the "in" operator, using a more advanced method like `Object.prototype.hasOwnProperty.call()` could potentially improve performance.
* For arrays, alternative approaches to `indexOf` include:
	+ Using `findIndex()`, which returns -1 if not found, making it similar to `indexOf`.
	+ Implementing a custom binary search algorithm for fast lookup.
	+ Using a data structure like a balanced tree or hash table.

Keep in mind that these alternatives might require more code and optimization effort, but can potentially lead to better performance in certain scenarios.

Latest run results:

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

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

Browser/OS: Chrome 128 on Windows

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	10385175.0 Ops/sec
Object in	9634507.0 Ops/sec
Array.indexOf	970.8 Ops/sec
direct	9462828.0 Ops/sec
Array includes	958.4 Ops/sec

Related benchmarks:

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

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

Created: 3 months 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 28 days ago):