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)));
}

Tests:

array.includes
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
object.hasOwnProperty
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
object[field]
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

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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

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.

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

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: 2 years ago by: Guest

Jump to the latest result

array.includes

Object.prototype.hasOwnProperty

object.hasOwnProperty

Reflect.has

object[field]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):