Benchmark: Object.hasOwn Set.prototype.has Object.prototype.hasOwnProperty in

Script Preparation code:

window.myObject = {};
window.mySet = new Set();
for (let i = 1; i < 1001; i++) {
  window.myObject[i] = null;
  window.mySet.add(i);
}

Tests:

Object.hasOwn
for (let i = 1000; i > 0; i--) { Object.hasOwn(window.myObject, i); }
Set.prototype.has
for (let i = 1000; i > 0; i--) { window.mySet.has(i); }
Object.prototype.hasOwnProperty
for (let i = 1000; i > 0; i--) { window.myObject.hasOwnProperty(i); }
in
for (let i = 1000; i > 0; i--) { i in window.myObject; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.hasOwn
Set.prototype.has
Object.prototype.hasOwnProperty
in

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; rv:133.0) Gecko/20100101 Firefox/133.0

Browser/OS: Firefox 133 on Windows

View result in a separate tab

Test name	Executions per second
Object.hasOwn	15110.4 Ops/sec
Set.prototype.has	15103.7 Ops/sec
Object.prototype.hasOwnProperty	15376.8 Ops/sec
in	15555.2 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 benchmarking test case and explain what it's testing, along with its pros and cons.

**Benchmark Overview**

The benchmark tests the performance of three different methods to check if an object has a specific property:

1. `Object.prototype.hasOwnProperty`
2. `Set.prototype.has` (not applicable in this context, as we're checking for an object property)
3. `in`

Additionally, it tests another method that's not relevant here: `Object.hasOwn`.

**Script Preparation Code**

The script preparation code creates two objects and a Set:
```javascript
window.myObject = {};
window.mySet = new Set();
for (let i = 1; i < 1001; i++) {
  window.myObject[i] = null;
  window.mySet.add(i);
}
```
This setup is done to ensure that each test case has a similar scope and object structure.

**HTML Preparation Code**

There is no HTML preparation code, which means the benchmark only runs in a headless browser context ( likely using Chrome's Headless mode).

**Test Cases**

The benchmark defines four test cases:

1. **Object.prototype.hasOwnProperty**: This method checks if an object has a specific property by calling `hasOwnProperty` on that property.
2. **Set.prototype.has**: Not applicable here, as we're checking for an object property. However, in general, this method would check if an element is present in a Set.
3. **in**: This method returns a boolean indicating whether the specified variable name exists in an object. It's generally faster than `hasOwnProperty` but may not be as secure.
4. **Object.hasOwn**: This method checks if an object has a specific property without calling `hasOwnProperty`. However, its implementation is less standard and might depend on the browser.

**Pros and Cons**

Here are some general pros and cons for each test case:

1. **Object.prototype.hasOwnProperty**:
	* Pros: more secure (respects prototype chain), can be faster due to browser optimizations.
	* Cons: less readable in some cases, may require additional checks for undefined values.
2. **in**:
	* Pros: fast, widely supported, and easy to read.
	* Cons: might not work with all object types, may have performance issues in certain situations.
3. **Object.hasOwn**: 
	* Pros: provides a more standard method (less prone to implementation variations), can help avoid indirect property checks.
	* Cons: less secure than `hasOwnProperty`, its implementation is browser-dependent.

**Library/Functionality Usage**

In this benchmark, we don't use any external libraries. However, the usage of the `Set` object and its methods (`has`) might be specific to certain browsers or versions.

**Special JavaScript Features/Syntax**

The benchmark doesn't explicitly use or test any special JavaScript features or syntax, such as async/await or arrow functions.

**Alternatives**

For this specific type of benchmarking (checking for property existence), other alternatives include:

* Using a testing library like Jest or Mocha
* Implementing a custom testing framework using a scripting language like Python or Node.js
* Utilizing existing benchmarking tools, such as Google's Benchmark or Intel's Threading Building Blocks

Keep in mind that the choice of alternative will depend on your specific requirements and use case.

**Conclusion**

In summary, this benchmark tests the performance of different methods to check if an object has a specific property. It provides insights into the execution speed and variation across different browsers, devices, and operating systems.

Related benchmarks:

Object.hasOwn Set.prototype.has Object.prototype.hasOwnProperty in (version: 0)

Comparing performance of: Object.hasOwn vs Set.prototype.has vs Object.prototype.hasOwnProperty vs in

Created: 3 years ago by: Guest

Jump to the latest result

Object.hasOwn

Set.prototype.has

Object.prototype.hasOwnProperty

in

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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