Benchmark: Object.prototype.hasOwnProperty vs obj.hasOwnProperty vs Object.hasOwn

Script Preparation code:

obj = {a: 42, b:66, c: 88}

Tests:

Object.prototype.hasOwnProperty
Object.prototype.hasOwnProperty.call(obj, 'b');
obj.hasOwnProperty
obj.hasOwnProperty('b');
Object.hasOwn
Object.hasOwn(obj, 'b')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.prototype.hasOwnProperty
obj.hasOwnProperty
Object.hasOwn

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 17 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0

Browser/OS: Firefox 137 on Windows

View result in a separate tab

Test name	Executions per second
Object.prototype.hasOwnProperty	999721984.0 Ops/sec
obj.hasOwnProperty	874041472.0 Ops/sec
Object.hasOwn	993050048.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is tested?**

The provided JSON represents a benchmark test that compares three different ways to check if a property exists in an object:

1. `Object.prototype.hasOwnProperty.call(obj, 'b')`
2. `obj.hasOwnProperty('b')`
3. `Object.hasOwn(obj, 'b')`

These three approaches are compared to determine which one is the fastest.

**Options comparison**

The three options being compared are:

* **1. `Object.prototype.hasOwnProperty.call(obj, 'b')`**: This method uses the `hasOwnProperty()` method of the object's prototype chain and returns a boolean value indicating whether the property exists in the object or not.
* **2. `obj.hasOwnProperty('b')`**: This method uses the `hasOwnProperty()` method of the object itself (not its prototype chain) to check if the property exists.
* **3. `Object.hasOwn(obj, 'b')`**: This method is a static method on the `Object` class that checks if an object has a given property.

**Pros and cons**

Here's a brief overview of each option:

1. **`Object.prototype.hasOwnProperty.call(obj, 'b')`**
	* Pros: It uses the `hasOwnProperty()` method of the object's prototype chain, which is a standardized way to check for properties in JavaScript.
	* Cons: It may not be as efficient as using the object's own `hasOwnProperty()` method (option 2), since it has to traverse the prototype chain.
2. **`obj.hasOwnProperty('b')`**
	* Pros: It uses the object's own `hasOwnProperty()` method, which can be faster than option 1 since it doesn't have to traverse the prototype chain.
	* Cons: It may not be as standardized or widely supported, since it relies on the object having a `hasOwnProperty()` method in its own prototype chain.
3. **`Object.hasOwn(obj, 'b')`**
	* Pros: It is a standardized way to check for properties in JavaScript and doesn't rely on the object's own methods.
	* Cons: It may be slower than option 2 since it has to traverse the object's prototype chain.

**Library and syntax**

In this benchmark, no libraries are used. The syntax is standard JavaScript, with no special features or syntax.

**Other considerations**

When writing microbenchmarks like these, it's essential to consider factors such as:

* Standardization: How widely supported is the approach being tested?
* Efficiency: How fast is the approach compared to others?
* Consistency: Are the test cases consistent in their requirements and behavior?

**Alternatives**

If you were to write a similar benchmark, you might also consider testing other approaches, such as:

* Using the `in` operator (e.g., `obj['b'] in obj`)
* Using a library like Lodash or Ramda for property checking
* Testing different versions of JavaScript (e.g., ES5, ES6, etc.)

However, it's worth noting that MeasureThat.net is specifically designed to test microbenchmarks related to property existence and iteration, so the focus on `hasOwnProperty()` and its variants is likely intentional.

Related benchmarks:

Object.prototype.hasOwnProperty vs obj.hasOwnProperty vs Object.hasOwn (version: 0)

Comparing performance of: Object.prototype.hasOwnProperty vs obj.hasOwnProperty vs Object.hasOwn

Created: 2 years ago by: Guest

Jump to the latest result

Object.prototype.hasOwnProperty

obj.hasOwnProperty

Object.hasOwn

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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