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

Script Preparation code:

  var object = {},
      array = [],
      i, test = 10000
  
  for (i = 0; i < 10000; 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.

Let's dive into the provided benchmark and explore what's being tested.

**Benchmark Overview**

The provided benchmark compares the performance of four different methods to check if a property exists in an object or array:

1. `object.hasOwnProperty('something' + test)`
2. `(something' + test) in object`
3. `array.indexOf('something' + test) !== -1`
4. `direct` (which checks for equality, assuming the value is always true)

**What are we comparing?**

We're comparing the execution time of these four methods to access a property in an object or array using a variable `$test`. The goal is to determine which method is the fastest.

**Options Compared**

* `object.hasOwnProperty('something' + test)`: This method checks if the object has a property with the given key. It's a simple and efficient way to check for existence.
* `(something' + test) in object`: This method uses the `in` operator, which returns true if the key exists in the object. It's similar to `hasOwnProperty`, but can be less efficient due to its broader scope.
* `array.indexOf('something' + test) !== -1`: This method searches for the key in the array and returns 0 if found or -1 if not. The `!== -1` check is used to determine existence.
* `direct`: This method checks for equality, assuming the value is always true. It's a simple but potentially slow way to access the property.

**Pros and Cons of Each Approach**

* `object.hasOwnProperty('something' + test)`: Pros: efficient, precise; Cons: limited by object key structure.
* `(something' + test) in object`: Pros: flexible, can be used with arrays; Cons: may be slower due to broader scope, potential for typos or out-of-scope errors.
* `array.indexOf('something' + test) !== -1`: Pros: flexible, can be used with any data structure; Cons: may be slower due to array search, potential for performance impact on large arrays.
* `direct`: Pros: simple, easy to read; Cons: potentially slow due to unnecessary checks, may not work as expected if value is falsey.

**Library and Special JS Features**

The benchmark uses the following library:

* No explicit libraries are mentioned, but it's likely that the browser being tested (Chrome) has its own built-in optimizations for these methods.
* There are no special JavaScript features or syntax used in this benchmark.

**Other Considerations**

* The benchmark is designed to measure performance on a specific test case, with 100,000 iterations.
* The results should be interpreted considering the test environment, browser version, and device platform.
* To get the most accurate results, it's recommended to run the benchmark multiple times to account for any variations.

**Alternatives**

If you want to write your own JavaScript benchmarks or compare performance of different methods, consider using a library like:

* Benchmark.js: A lightweight, easy-to-use benchmarking library that allows you to create and run benchmarks.
* Microbenchmark: A popular benchmarking library specifically designed for JavaScript microbenchmarks.

Keep in mind that these alternatives might offer more features and flexibility than MeasureThat.net's built-in benchmarking capabilities.

Latest run results:

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

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

Browser/OS: Chrome 127 on Linux

View result in a separate tab

Test name	Executions per second
Object.hasOwnProperty	11170897.0 Ops/sec
Object in	10310120.0 Ops/sec
Array.indexOf	168909.5 Ops/sec
direct	10335731.0 Ops/sec
Array includes	173754.6 Ops/sec

Related benchmarks:

Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes times 100000 (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):