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

Script Preparation code:

  var object = {},
      array = [],
      set = new Set(),
      i, test = 1000;
  
  for (i = 0; i < 1000; i++) {
   object['something' + i] = true;
   array.push('something' + i);
   set.add('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]
Array includes
array.includes('something' + test)
Set has
set.has('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
Set has

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.

I'll break down the provided benchmark definitions and explain what's being tested, along with their pros and cons.

**Benchmark Definition**

The website `MeasureThat.net` allows users to create and run JavaScript microbenchmarks. The provided benchmark definition is:

```
{
  "Name": "Object.hasOwnProperty vs Object in vs Object[] vs Array.indexOf vs Array.includes vs Set.has 2",
  "Description": null,
  "Script Preparation Code": "...",
  "Html Preparation Code": null
}
```

This benchmark compares the performance of six different approaches to check if a property exists or can be found on an object:

1. `Object.hasOwnProperty`
2. `Object in`
3. `Object[]` (which is not a valid syntax, but might have been intended as a comparison with array-based indexing)
4. `Array.indexOf`
5. `Array.includes`
6. `Set.has`

The pros and cons of each approach are:

1. **`Object.hasOwnProperty`**:
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not work well for objects with many properties (performance issues).
2. **`Object in`**:
	* Pros: Similar to `hasOwnProperty`, but may be faster due to its use of a special property lookup.
	* Cons: Not supported in older browsers or versions of JavaScript.
3. **Invalid `Object[]`**: As mentioned, this is not a valid syntax and should not be used.
4. **`Array.indexOf`**:
	* Pros: Fast for arrays with many elements, as it uses binary search.
	* Cons: May return -1 if the element is not found, which can lead to unexpected behavior in some cases.
5. **`Array.includes`**:
	* Pros: Faster and more readable than `indexOf`, as it returns a boolean value directly.
	* Cons: Introduced in ECMAScript 2015 (ES6), so may not be supported in older browsers or versions of JavaScript.
6. **`Set.has`**:
	* Pros: Fast and efficient, especially for large sets.
	* Cons: Requires a Set object to be created and populated with elements.

**Individual Test Cases**

The test cases are defined as:

```
[
  {
    "Benchmark Definition": "...",
    "Test Name": "..."
  },
  ...
]
```

Each test case represents one of the six approaches listed above, and their raw execution times are stored in the `ExecutionsPerSecond` field.

**Other Considerations**

* The benchmark uses a Windows NT 10.0; Win64; x64; rv:101.0 Gecko/20100101 Firefox/101.0 browser string as the User Agent (UA) for testing, which is specific to this Firefox version.
* The `RawUAString` field provides additional information about the test environment.

**Alternatives**

If you're looking for alternative approaches or alternatives in JavaScript, some options might include:

* Using a library like Lodash to provide a unified way of checking property existence across different data structures (e.g., objects, arrays, sets).
* Implementing your own custom method for checking property existence, such as using a binary search algorithm.
* Considering the use of more modern JavaScript features, like `in` and `has`, which are designed for this purpose.

However, it's essential to note that these alternatives might not be as efficient or well-supported as the original approaches listed in the benchmark.

Related benchmarks:

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

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

Created: 5 years ago by: Guest

Jump to the latest result

Object.hasOwnProperty

Object in

Array.indexOf

direct

Array includes

Set has

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):