Benchmark: in operator vs typeof vs hasOwnProperty

Script Preparation code:


const testObj = {};

for (let i = 0; i < 1000; i++)
{
  const kvText = i + '-' + i;
  testObj[kvText] = kvText;
}


window.testObj = testObj;

Tests:

in operator
'test' in testObj; '500-500' in testObj;
typeof
typeof testObj.test !== 'undefined'; typeof testObj['500-500'] !== 'undefined';
hasOwnProperty
const hop = Object.prototype.hasOwnProperty; hop.call(testObj, 'test'); hop.call(testObj, '500-500');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
in operator
typeof
hasOwnProperty

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of three different approaches to check if a property exists in an object:

1. The "in" operator (e.g., `test` in `testObj`)
2. `typeof` with a check for `undefined` (e.g., `typeof testObj.test !== 'undefined'`)
3. The `hasOwnProperty` method (e.g., `Object.prototype.hasOwnProperty.call(testObj, 'test')`)

**Pros and Cons of each approach:**

1. **"in" operator**:
	* Pros: Simple, efficient, and widely supported.
	* Cons: May not work correctly with certain types of objects or properties (e.g., symbol properties).
2. `typeof` with a check for `undefined`:
	* Pros: Works well with all types of properties, including symbols. However, it may be slower due to the need to perform multiple checks.
	* Cons: Less efficient than the "in" operator and more complex to write.
3. `hasOwnProperty` method:
	* Pros: Highly optimized and fast, as it's a native method on Object prototypes.
	* Cons: May not work correctly with certain types of objects or properties (e.g., objects without prototype chains).

**Library and purpose**

The `hasOwnProperty` method is a built-in method on the `Object.prototype`. Its purpose is to check if an object has a property with the given name.

**Special JavaScript feature or syntax**

None mentioned in this benchmark definition. However, it's worth noting that modern JavaScript engines have optimized various aspects of the language, such as performance and memory usage.

**Other alternatives**

For checking if a property exists in an object, you can also use:

* `in` operator with bracket notation: `(testObj['test'] !== undefined)`
* `Object.prototype.hasOwnProperty.call()`: Similar to the `hasOwnProperty` method, but allows for more flexibility.
* `Object.keys()`, `Object.getOwnPropertyNames()`, or `Object.getOwnPropertySymbols()` followed by a check for an empty array or string.

It's essential to note that these alternatives may have different performance characteristics and use cases compared to the "in" operator and `hasOwnProperty` method.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/21A329 Twitter for iPhone/10.7

Browser/OS: Mobile Safari 17 on iOS 17.0

View result in a separate tab

Test name	Executions per second
in operator	7882607.5 Ops/sec
typeof	7824934.5 Ops/sec
hasOwnProperty	5120824.5 Ops/sec

Related benchmarks:

in operator vs typeof vs hasOwnProperty (version: 0)

We're going to measure the performance for checking the property if it exists or not.

Comparing performance of: in operator vs typeof vs hasOwnProperty

Created: one year ago by: Guest

Jump to the latest result

in operator

typeof

hasOwnProperty

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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