Benchmark: Array.includes vs Object.hasOwnProperty vs Reflect.has vs object[id]

Script Preparation code:

var ids = [''];
var entities = { '': { id: '', number: 10000 } };
var id = '';

for (let i = 0; i < 10000; i++) {
  id = String(i);
  ids.push(id);
  entities[id] = { id, number: i }
}

function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min) + min); //The maximum is exclusive and the minimum is inclusive
}

var idsFind = [''];

for (let i = 0; i < 100; i++) {
  idsFind.push(String(getRandomInt(0, 20000)));
}

​x
 
var ids = [''];var entities = { '': { id: '', number: 10000 } };var id = '';​for (let i = 0; i < 10000; i++) {  id = String(i);  ids.push(id);  entities[id] = { id, number: i }}​function getRandomInt(min, max) {  min = Math.ceil(min);  max = Math.floor(max);  return Math.floor(Math.random() * (max - min) + min); //The maximum is exclusive and the minimum is inclusive}​var idsFind = [''];​for (let i = 0; i < 100; i++) {  idsFind.push(String(getRandomInt(0, 20000)));}

Tests:

array.includes

var result = [];

for (const id of idsFind) {
  if (ids.includes(id)) {
    result.push(entities[id])
  }
}

return result

 
var result = [];​for (const id of idsFind) {  if (ids.includes(id)) {    result.push(entities[id])  }}​return result

Object.prototype.hasOwnProperty
var result = []; for (const id of idsFind) { if (Object.prototype.hasOwnProperty.call(entities, id)) { result.push(entities[id]) } } return result
var result = [];

for (const id of idsFind) {
if (Object.prototype.hasOwnProperty.call(entities, id)) {
result.push(entities[id])
}
}

return result
object.hasOwnProperty
var result = []; for (const id of idsFind) { if (entities.hasOwnProperty(id)) { result.push(entities[id]) } } return result
var result = [];

for (const id of idsFind) {
if (entities.hasOwnProperty(id)) {
result.push(entities[id])
}
}

return result

Reflect.has

var result = [];

for (const id of idsFind) {
  if (Reflect.has(entities, id)) {
    result.push(entities[id])
  }
}

return result

 
var result = [];​for (const id of idsFind) {  if (Reflect.has(entities, id)) {    result.push(entities[id])  }}​return result

object[field]

var result = [];

for (const id of idsFind) {
  if (entities[id] != null) {
    result.push(entities[id])
  }
}

return result

 
var result = [];​for (const id of idsFind) {  if (entities[id] != null) {    result.push(entities[id])  }}​return result

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
array.includes
Object.prototype.hasOwnProperty
object.hasOwnProperty
Reflect.has
object[field]

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
array.includes	1411.2 Ops/sec
Object.prototype.hasOwnProperty	65704.2 Ops/sec
object.hasOwnProperty	137055.4 Ops/sec
Reflect.has	66023.7 Ops/sec
object[field]	136134.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):

Benchmark Overview

The provided benchmark measures the performance of four different approaches to check if an object has a property with a given key: Array.includes, Object.prototype.hasOwnProperty, object.hasOwnProperty, and Reflect.has. The test creates an array of 10,000 random IDs and an objects with corresponding values. It then iterates over the IDs and checks if each ID exists in the array or as a property of the object using each of the four approaches.

Approaches Compared

Array.includes: This method uses the includes() method on the array to check if a value is present.
Object.prototype.hasOwnProperty: This method uses the hasOwnProperty() method on the object's prototype to check if a property exists.
object.hasOwnProperty: This method uses the hasOwnProperty() method directly on the object itself, bypassing the prototype chain.
Reflect.has: This method uses the Reflect.has() function to check if an object has a property with a given key.

Pros and Cons of Each Approach

Array.includes:
- Pros: Simple, widely supported, and fast.
- Cons: May not be as efficient for large arrays or objects, as it requires creating an iterator or using indexOf() which can be slower.
Object.prototype.hasOwnProperty:
- Pros: Works well with large objects, as it only checks the prototype chain up to the object itself.
- Cons: May not work correctly if the object has a complex prototype chain, and it's being phased out in favor of Reflect.has() for better performance.
object.hasOwnProperty:
- Pros: More efficient than Object.prototype.hasOwnProperty as it doesn't traverse the prototype chain.
- Cons: Only works on objects, not arrays or other data structures.
Reflect.has:
- Pros: Fast, modern, and widely supported across browsers and Node.js versions.
- Cons: May require more code changes as it's a relatively new feature.

Library and Syntax

None of the approaches use any external libraries or special JavaScript features beyond the basic syntax provided by the language. However, it's worth noting that Reflect.has() is a modern feature introduced in ECMAScript 2020 (ES2020).

Other Considerations

When choosing between these approaches, consider the following:

Performance: If you need extremely high performance, Reflect.has() might be the best choice.
Compatibility: If you need to support older browsers or environments, Array.includes or Object.prototype.hasOwnProperty might be a better option.
Code Readability: If code readability is important, using Object.prototype.hasOwnProperty or object.hasOwnProperty might be a better choice as they are more explicit about their purpose.

Alternatives

Other alternatives for checking if an object has a property with a given key include:

Using the in operator: if (key in obj) { ... }
Using the has() method on data structures like sets or maps
Implementing custom logic using bitwise operators or other optimization techniques

However, these alternatives might not be as widely supported or efficient as the approaches compared in this benchmark.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of four different approaches to check if an object has a property with a given key: `Array.includes`, `Object.prototype.hasOwnProperty`, `object.hasOwnProperty`, and `Reflect.has`. The test creates an array of 10,000 random IDs and an objects with corresponding values. It then iterates over the IDs and checks if each ID exists in the array or as a property of the object using each of the four approaches.

**Approaches Compared**

1. **Array.includes**: This method uses the `includes()` method on the array to check if a value is present.
2. **Object.prototype.hasOwnProperty**: This method uses the `hasOwnProperty()` method on the object's prototype to check if a property exists.
3. **object.hasOwnProperty**: This method uses the `hasOwnProperty()` method directly on the object itself, bypassing the prototype chain.
4. **Reflect.has**: This method uses the `Reflect.has()` function to check if an object has a property with a given key.

**Pros and Cons of Each Approach**

1. **Array.includes**:
	* Pros: Simple, widely supported, and fast.
	* Cons: May not be as efficient for large arrays or objects, as it requires creating an iterator or using `indexOf()` which can be slower.
2. **Object.prototype.hasOwnProperty**:
	* Pros: Works well with large objects, as it only checks the prototype chain up to the object itself.
	* Cons: May not work correctly if the object has a complex prototype chain, and it's being phased out in favor of `Reflect.has()` for better performance.
3. **object.hasOwnProperty**:
	* Pros: More efficient than `Object.prototype.hasOwnProperty` as it doesn't traverse the prototype chain.
	* Cons: Only works on objects, not arrays or other data structures.
4. **Reflect.has**:
	* Pros: Fast, modern, and widely supported across browsers and Node.js versions.
	* Cons: May require more code changes as it's a relatively new feature.

**Library and Syntax**

None of the approaches use any external libraries or special JavaScript features beyond the basic syntax provided by the language. However, it's worth noting that `Reflect.has()` is a modern feature introduced in ECMAScript 2020 (ES2020).

**Other Considerations**

When choosing between these approaches, consider the following:

* **Performance**: If you need extremely high performance, `Reflect.has()` might be the best choice.
* **Compatibility**: If you need to support older browsers or environments, `Array.includes` or `Object.prototype.hasOwnProperty` might be a better option.
* **Code Readability**: If code readability is important, using `Object.prototype.hasOwnProperty` or `object.hasOwnProperty` might be a better choice as they are more explicit about their purpose.

**Alternatives**

Other alternatives for checking if an object has a property with a given key include:

* Using the `in` operator: `if (key in obj) { ... }`
* Using the `has()` method on data structures like sets or maps
* Implementing custom logic using bitwise operators or other optimization techniques

However, these alternatives might not be as widely supported or efficient as the approaches compared in this benchmark.

Related benchmarks:

Array.includes vs Object.hasOwnProperty vs Reflect.has vs object[id] (version: 0)

Comparing performance of: array.includes vs Object.prototype.hasOwnProperty vs object.hasOwnProperty vs Reflect.has vs object[field]

Created: 3 years ago by: Guest

Jump to the latest result