Benchmark: undefined vs. typeof vs. in vs. hasOwnProperty vs Object.hasOwn

Script Preparation code:

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

Tests:

undefined
undefined !== obj.d;
typeof
'undefined' !== typeof obj.d;
in
'd' in obj;
hasOwnProperty
obj.hasOwnProperty( 'd' );
bool
!! obj.d;
hasOwn
Object.hasOwn(obj, 'd');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwnProperty
bool
hasOwn

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
undefined	321846144.0 Ops/sec
typeof	717950784.0 Ops/sec
in	719298624.0 Ops/sec
hasOwnProperty	103936016.0 Ops/sec
bool	711024256.0 Ops/sec
hasOwn	76356144.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark test.

**Overview**

The benchmark measures the performance of different ways to check if a property exists in an object, specifically `undefined`, `typeof`, `in`, `hasOwnProperty`, and two custom approaches, `bool` and `hasOwn`. The test creates an object with five properties (a, b, c, d, e) and checks each of the six options.

**Options being compared**

1. **`undefined !== obj.d`**: This is the most straightforward way to check if a property exists in an object. If the property is defined but `undefined`, it's not found.
2. **`'undefined' !== typeof obj.d`**: This checks if the value of `obj.d` is equal to `'undefined'`. It's similar to the first option, but uses a string literal instead of comparing directly with `undefined`.
3. **`'d' in obj`**: This uses the `in` operator to check if the property `'d'` exists in the object.
4. **`obj.hasOwnProperty('d')`**: This method is called on the object to check if it has the property `'d'`. It returns a boolean indicating whether the property exists or not.
5. **`!! obj.d`**: This uses a boolean cast (`!!`) to convert `obj.d` to a boolean value, where `undefined` becomes `false` and defined values become `true`.
6. **`Object.hasOwn(obj, 'd')`**: This method is called on the global `Object` object to check if it has the property `'d'`. It returns a boolean indicating whether the property exists or not.

**Pros and Cons**

1. **`undefined !== obj.d`**: Fastest, as it directly compares the value with `undefined`.
2. **`'undefined' !== typeof obj.d`**: Similar to the first option but with an additional overhead due to string comparison.
3. **`'d' in obj`**: Faster than `hasOwnProperty`, but still relatively fast.
4. **`obj.hasOwnProperty('d')`**: More efficient for objects, as it uses a specialized method to check property existence.
5. **`!! obj.d`**: Faster than using `in` or `hasOwnProperty`, as it avoids the overhead of operator overloading and returns a simple boolean value.
6. **`Object.hasOwn(obj, 'd')`**: Generally slower than other methods due to its additional overhead.

**Other considerations**

* Using `in` can be slower than other methods because it needs to iterate through the object's property descriptors.
* `hasOwnProperty` is more efficient for objects but may not work as expected in some cases (e.g., when used with `Object.create()`).
* The custom approaches (`bool` and `!!`) are simple, lightweight alternatives that rely on JavaScript's built-in behavior.

**Library used**

None mentioned in the benchmark definition. However, it is worth noting that some of these methods may be specific to certain browsers or environments (e.g., older versions of Internet Explorer).

**Special JS feature/syntax**

No special features or syntax are being tested in this benchmark. The focus is on measuring performance differences between various property existence checks.

Please let me know if you have any further questions!

Related benchmarks:

undefined vs. typeof vs. in vs. hasOwnProperty vs Object.hasOwn (version: 0)

Object lookup performance

Comparing performance of: undefined vs typeof vs in vs hasOwnProperty vs bool vs hasOwn

Created: 2 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

bool

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