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

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

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.5.1

View result in a separate tab

Object.hasOwnProperty

12.7M/s

Object in

12.0M/s

direct

11.5M/s

Array.indexOf

730K/s

Array includes

269K/s

View exact numbers

Test name	Executions per second
✓ Object.hasOwnProperty	12,656,720 Ops/sec
Object in	11,975,800 Ops/sec
direct	11,466,132 Ops/sec
Array.indexOf	730,114 Ops/sec
Array includes	269,173 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definition and explain what's being tested, the pros and cons of different approaches, and other considerations.

**Benchmark Definition**

The benchmark measures the performance of four different ways to check if a property exists in an object or array:

1. `Object.hasOwnProperty`
2. `Object in`
3. `Array.indexOf` (note: this is not strictly checking for existence, but rather finding the index of the value)
4. `Array.includes`

**Script Preparation Code**

The script preparation code creates two objects and arrays:

* An object (`object`) with 1000 properties, each initialized to `true`.
* An array (`array`) with 1000 elements, each containing a string.

This setup is likely designed to maximize the chances of finding a match when checking for existence.

**Individual Test Cases**

Each test case checks if a specific property exists in the object or array using one of the four methods:

1. `object.hasOwnProperty('something' + test)`
2. `'something' + test` in `object`
3. `array.indexOf('something' + test) !== -1`
4. `array.includes('something' + test)`

**Pros and Cons**

Here's a brief analysis of each approach:

1. **Object.hasOwnProperty**
	* Pros: Simple, straightforward, and widely supported.
	* Cons: Can be slower than other approaches for large objects due to the overhead of property lookup.
2. **Object in**
	* Pros: Similar performance to `hasOwnProperty` for small objects, but may be slower for large ones.
	* Cons: Less readable and less intuitive than `hasOwnProperty`.
3. **Array.indexOf**
	* Pros: Fast and efficient for arrays, as it uses binary search.
	* Cons: Not designed for existence checks; returns the index of the first occurrence or -1 if not found. May be slower than other approaches for small arrays.
4. **Array.includes**
	* Pros: Similar performance to `indexOf` for small arrays, and more readable for existence checks.
	* Cons: Less efficient than `indexOf` for large arrays due to the overhead of string lookup.

**Other Considerations**

* **Cache locality**: The use of a large object with many properties may lead to better cache locality, reducing the number of memory accesses and improving performance.
* **Virtual machine**: JavaScript engines like V8 (used by Chrome) have a virtual machine that can optimize certain operations. This might affect the relative performance of different approaches.
* **Compiler optimizations**: The compiler can also impact performance, as it may optimize away unnecessary branches or loops.

**Library**

The `includes` method uses the `String.prototype.includes` method, which is implemented in JavaScript standards and optimized by most browsers.

**Special JS Feature/Syntax**

There is no specific JavaScript feature or syntax mentioned in this benchmark. However, the use of template literals (e.g., `'something' + test`) is a relatively modern feature introduced in ECMAScript 2015.

**Alternatives**

If you're looking for alternative approaches to check if an object property exists, consider using:

* `Object.keys().includes(key)`: A more modern and readable approach that uses the `keys()` method.
* `Array.prototype.some()`: A more efficient approach that uses a single loop.
* Native methods like `Map.has` or `Set.has`, which are optimized for existence checks.

Keep in mind that these alternatives might have different performance characteristics depending on your specific use case and JavaScript engine.

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

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

Created: 2 years ago by: Guest

Go 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

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

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

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

Created: 2 years ago by: Guest

Go 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

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

Related benchmarks

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