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

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')
in obj
'b' in obj

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

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/112.0.0.0 Safari/537.36

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
Object.prototype.hasOwnProperty	4213763.5 Ops/sec
obj.hasOwnProperty	7794651.5 Ops/sec
Object.hasOwn	3983933.0 Ops/sec
in obj	8092113.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is tested in the provided JSON benchmark.

**Benchmark Definition:**

The benchmark measures the performance of four different approaches 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')`
4. `'b' in obj`

These approaches are tested because they have slightly different performance characteristics.

**Options Compared:**

The four options compared are:

* Using the `hasOwnProperty` method directly on the object (`obj.hasOwnProperty('b')`)
* Using the `hasOwnProperty` method via a call to `Object.prototype.hasOwnProperty.call()`
* Using a static method `Object.hasOwn()` (introduced in ECMAScript 5)
* Using the syntax `'b' in obj`

**Pros and Cons:**

1. **Using `obj.hasOwnProperty('b')`**: This is the most straightforward approach, as it only requires calling a single method on the object.
	* Pros: Simple to read and write, no additional objects are created.
	* Cons: May have performance overhead due to method call and possibly some internal loop optimizations.
2. **Using `Object.prototype.hasOwnProperty.call(obj, 'b')`**: This approach uses an indirect call through `Object.prototype`, which might be slower than the direct call on the object.
	* Pros: Might provide additional benefits like better error handling or more fine-grained control over errors.
	* Cons: Adds unnecessary overhead due to the indirect call and potential function lookup.
3. **Using `Object.hasOwn(obj, 'b')`**: This is a static method that can be called without creating an object (since `Object.prototype` is still available).
	* Pros: Can provide better performance than the dynamic method call on `obj`.
	* Cons: Might not work in older browsers or environments where `Object.prototype` is not available.
4. **Using `'b' in obj`**: This approach uses a property access operator (`in`) to check if the object has the specified property.
	* Pros: Simple and concise, might be faster due to direct hardware support for the operator.
	* Cons: May have performance overhead due to the creation of an intermediate string or the use of some internal loop optimizations.

**Library/Functionality Used:**

None of these options rely on a specific library or external functionality. They are all built-in JavaScript features that can be used without additional setup.

**Special JS Features/Syntax:**

* `Object.prototype.hasOwnProperty.call()`, `Object.hasOwn()`: These methods were introduced in ECMAScript 5 and provide more flexible error handling and better support for non-native objects.
* `'b' in obj`: This syntax is a property access operator, which was introduced in ECMAScript 2008.

**Alternatives:**

If you want to explore other approaches or alternatives, consider the following:

* Using `in` with an array: Instead of using `'a' in obj`, try using `in obj`. The array will act as a key and may provide better performance due to its shorter length.
* Using a native iterator: Some browsers (like Firefox) support native iterators. You can explore using the `for...of` loop or other iteration methods to test object property existence.

Keep in mind that these alternatives might not be supported by all browsers or environments, so ensure you're testing with compatible systems before running your benchmark.

Related benchmarks:

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

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

Created: one year ago by: Registered User

Jump to the latest result

Object.prototype.hasOwnProperty

obj.hasOwnProperty

Object.hasOwn

in obj

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):