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

Script Preparation code:

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

Tests:

undefined
undefined !== obj.d; undefined !== obj2.d;
typeof
'undefined' !== typeof obj.d; 'undefined' !== typeof obj2.d;
in
'd' in obj; 'd' in obj2;
hasOwnProperty
obj.hasOwnProperty( 'd' ); obj2.hasOwnProperty( 'd' );
bool
!! obj.d; !! obj2.d;
hasOwn
Object.hasOwn(obj, 'd'); Object.hasOwn(obj2, '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:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):

LLMs can make mistakes. Check important info.

This benchmark tests the performance of various methods for checking if a property exists on an object in JavaScript.

Here's a breakdown of each approach and its pros/cons:

**1. `undefined !== obj.d`**: This method directly accesses the property `d` and compares it to `undefined`.

* **Pros:**  Concise and potentially fast if the property exists.
* **Cons:** Can throw an error if the property doesn't exist (TypeError).

**2. `'undefined' !== typeof obj.d`**: This uses the `typeof` operator to determine the type of the property and compares it to the string "undefined".

* **Pros:**  Doesn't throw an error if the property doesn't exist, returns "undefined" instead.
* **Cons:** Can be slower than direct access as it involves a type check.

**3. `'d' in obj`**: This uses the `in` operator to check if the property exists as a key within the object.

* **Pros:** Fast and reliable for checking existence of properties. Doesn't throw errors.
* **Cons:** Doesn't distinguish between own properties and inherited ones.

**4. `obj.hasOwnProperty( 'd' )`**: This uses the `hasOwnProperty` method to check if the property is directly owned by the object (not inherited).

* **Pros:**  Accurate for determining own properties.
* **Cons:** Can be slightly slower than `in` due to the method call.

**5. `!! obj.d`**: This uses the double negation operator (`!!`) to convert the property value to a boolean. If it's truthy (not `undefined`, `null`, 0, "", etc.), it returns true; otherwise, false.

* **Pros:**  Concise and potentially faster than other methods if the property value is already truthy or falsy.
* **Cons:** Can be confusing and less readable.

**6. `Object.hasOwn(obj, 'd')`**: This uses the `hasOwn` method from the `Object` object to check for direct ownership of a property.

* **Pros:**  Direct way to check own properties, consistent with `hasOwnProperty`.
* **Cons:** Might be slightly less performant than `hasOwnProperty`.

**Alternatives:** 
While these options are common, newer ECMAScript features like optional chaining (`?.`) and nullish coalescing (`??`) can provide cleaner and safer ways to access properties without explicitly checking for their existence.

**Important Note:** Benchmark results can vary significantly based on the JavaScript engine, browser version, hardware, and other factors.  It's essential to consider multiple benchmarks and real-world usage patterns when choosing an approach.

Related benchmarks:

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

Object lookup performance

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

Created: 3 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

bool

hasOwn

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):