Benchmark: Has own property

Script Preparation code:

var o = { path: "a" }

Tests:

Using `in`
!("path" in o)
Using `hasOwn()`
Object.hasOwn(o, "path")
Using `hasOwnProperty()`
o.hasOwnProperty("path")
Using `undefined` check
o.path === undefined

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using `in`
Using `hasOwn()`
Using `hasOwnProperty()`
Using `undefined` check

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

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
Using `in`	11995021.0 Ops/sec
Using `hasOwn()`	4204368.5 Ops/sec
Using `hasOwnProperty()`	10830504.0 Ops/sec
Using `undefined` check	4211546.5 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark on the website MeasureThat.net. The benchmark tests whether an object has a specific property. In this case, the benchmark checks if an object `o` has a property called `"path"`.

**Options compared:**

There are four options compared:

1. **"Using in"`**: This option uses the `in` operator to check if the property exists in the object.
2. **"Using hasOwn()"**: This option uses the `hasOwn()` method, which is a non-standard way of checking if an object has a specific property. Note that this method is not supported by all browsers and should be used with caution.
3. **"Using hasOwnProperty()"**: This option uses the `hasOwnProperty()` method, which is also a non-standard way of checking if an object has a specific property. Like `hasOwn()`, this method is not supported by all browsers.
4. **"Using undefined check"`: This option checks if the property exists by comparing its value to `undefined`.

**Pros and Cons:**

1. **"Using in"`**: This is a widely supported and efficient way of checking if an object has a specific property. It works well in most browsers, including modern ones.
	* Pros: Fast, widely supported, and easy to use.
	* Cons: None notable.
2. **"Using hasOwn()"**: While this method may seem convenient, it's not widely supported by browsers. Using `in` instead is recommended.
	* Pros: None notable.
	* Cons: Not supported in all browsers.
3. **"Using hasOwnProperty()"**: Similar to `hasOwn()`, this method is not supported by all browsers and should be used with caution.
	* Pros: None notable.
	* Cons: Not supported in all browsers.
4. **"Using undefined check"`: This approach can lead to unexpected results if the property exists but is not explicitly defined as a property (e.g., due to inheritance).
	* Pros: None notable.
	* Cons: Can lead to incorrect results in certain cases.

**Library and purpose:**

None of these options use a specific JavaScript library. They are built-in methods or operators.

**Special JS features or syntax:**

None of the test cases use special JavaScript features or syntax.

**Other alternatives:**

If you need to check if an object has a property, `in` is usually the best option. However, if you're working with legacy browsers that don't support `in`, you may need to use other methods like `hasOwnProperty()` or implement your own solution.

Related benchmarks:

Has own property (version: 0)

Check if an object is undefined

Comparing performance of: Using `in` vs Using `hasOwn()` vs Using `hasOwnProperty()` vs Using `undefined` check

Created: one year ago by: Registered User

Jump to the latest result

Using `in`

Using `hasOwn()`

Using `hasOwnProperty()`

Using `undefined` check

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