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

Script Preparation code:

var obj = { a: 1, b: 2, c: 3, d: 4, e: 5 };

Tests:

in
'c' in obj
Object.hasOwn
Object.hasOwn(obj, 'c')
Object.prototype.hasOwnProperty
obj.hasOwnProperty('c')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
in	15561238.0 Ops/sec
Object.hasOwn	7685934.5 Ops/sec
Object.prototype.hasOwnProperty	14069137.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases.

**Benchmark Definition**

The benchmark is defined by a JSON object that specifies:

* `Name`: The name of the benchmark, which is "in vs Object.hasOwn vs Object.prototype.hasOwnProperty".
* `Description`: An empty string, indicating that no description is provided.
* `Script Preparation Code`: A JavaScript code snippet that creates an object `obj` with five properties: `a`, `b`, `c`, `d`, and `e`. This code will be executed before running the benchmark.
* `Html Preparation Code`: An empty string, indicating that no HTML preparation is required.

**Test Cases**

The benchmark consists of three test cases:

1. **"in"**: Tests the usage of the `in` operator to check if a property exists in an object.
2. **"Object.hasOwn(obj, 'c')"**: Tests the usage of the `Object.hasOwn()` method to check if an object has a specific property.
3. **"obj.hasOwnProperty('c')"**: Tests the usage of the `hasOwnProperty()` method on the `obj` prototype to check if it has a specific property.

**What is tested?**

The benchmark tests how these three approaches compare in terms of performance when checking if a property exists in an object:

* Using the `in` operator
* Using the `Object.hasOwn()` method
* Using the `hasOwnProperty()` method on the prototype

These methods all achieve similar results, but they have different implementations and possible optimizations.

**Options compared**

The benchmark compares three options for checking if a property exists in an object:

1. **In operator**: The `in` operator checks if a property exists in an object by looking it up in the object's internal properties table.
2. **Object.hasOwn() method**: This method uses the `hasOwnProperty()` method on the object itself, which is called when the property name starts with two underscores (i.e., `_`). For other properties, it checks if the object has a `hasOwnProperty()` method that returns true for that property name.
3. **hasOwnProperty() method on prototype**: This approach calls the `hasOwnProperty()` method directly on the object's prototype, which can be faster than calling it on the object itself.

**Pros and cons of each approach**

Here are some pros and cons of each approach:

* **In operator**: Fastest but less readable. It's a simple and efficient way to check if a property exists.
* **Object.hasOwn() method**: More readable and widely supported, but slightly slower than the `in` operator.
	+ Pros: More readable, widely supported
	+ Cons: Slightly slower
* **hasOwnProperty() method on prototype**: Fastest when the property is not present in the object's own properties. Can be slower if it is present.
	+ Pros: Fast, doesn't rely on `hasOwnProperty()` being available on all objects
	+ Cons: Can be slower if the property is present

**Library and purpose**

None of these approaches use a specific library, but they do demonstrate different aspects of how JavaScript engines optimize property lookups.

**Special JS feature or syntax**

The benchmark uses the `in` operator, which is a native JavaScript feature. There are no special features or syntaxes used here.

**Alternatives**

Other alternatives for checking if a property exists in an object include:

* Using the `hasOwnProperty()` method on the object itself
* Checking if the property name starts with two underscores (i.e., `_`) and then using the `in` operator or `Object.hasOwn()`
* Using a library like Lodash's `has()` function

Note that these alternatives may have different performance characteristics and are not always equivalent to the approaches tested in this benchmark.

Related benchmarks:

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

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

Created: 3 months ago by: Guest

Jump to the latest result

in

Object.hasOwn

Object.prototype.hasOwnProperty

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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