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

Script Preparation code:

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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks to compare the performance of different approaches. The benchmark in question tests five methods for checking if a property exists or can be found within an object, array, or array with `indexOf` method.

**Tested Approaches**

The test compares the following approaches:

1. **Object.hasOwnProperty**
2. **Object in**
3. **Array.indexOf !== -1**
4. **direct**: A simple property access using bracket notation (`object['something' + test] === true`)
5. **Array includes**: Using the `includes` method to check if an element exists in an array

**Options Compared**

The test compares the performance of these five approaches on a large dataset of 50,000 objects and 50,000 elements.

**Pros and Cons of Each Approach:**

1. **Object.hasOwnProperty**:
	* Pros: Simple and efficient, as it only checks if the property exists in the object.
	* Cons: May be slower than other methods for very large datasets due to its simplicity.
2. **Object in**:
	* Pros: Similar to `hasOwnProperty`, but with a slightly more modern syntax.
	* Cons: May have similar performance characteristics as `hasOwnProperty`.
3. **Array.indexOf !== -1**:
	* Pros: Can be faster than other methods for large datasets, as it uses an index-based approach.
	* Cons: May be slower for very small datasets due to the overhead of searching for the index.
4. **direct**:
	* Pros: Simple and efficient, with minimal overhead.
	* Cons: May not be suitable for very large datasets or objects with many properties.
5. **Array includes**:
	* Pros: Modern syntax and relatively fast performance.
	* Cons: May have slightly slower performance than `indexOf !== -1` due to the overhead of regular expressions.

**Library Used**

The test uses no external libraries beyond standard JavaScript features.

**Special JS Features or Syntax**

None mentioned, but it's worth noting that some browsers may optimize certain methods using WebAssembly or other advanced technologies.

**Alternatives**

Other approaches could be used for this benchmark, such as:

* Using a library like Lodash with `has` function
* Implementing a custom hash table or data structure to store and query objects and arrays
* Using a different data structure, like a sparse array or an object with optimized property access

However, these alternatives are not tested in the provided benchmark.

Related benchmarks:

Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes 50k (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>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):