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

Script Preparation code:

const 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;
hasOwn
Object.hasOwn(obj, 'd');
bool
!! obj.d;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwn
bool

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 131 on Android

View result in a separate tab

Test name	Executions per second
undefined	37448980.0 Ops/sec
typeof	40375368.0 Ops/sec
in	35642988.0 Ops/sec
hasOwn	19054142.0 Ops/sec
bool	39150148.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark "undefined vs. typeof vs. in vs. hasOwn" is designed to evaluate the performance of various JavaScript approaches to checking if a property exists on an object. The object being tested contains several properties (`a`, `b`, `c`, `d`, `e`) to allow for various lookup strategies. Here’s a detailed breakdown of the test cases and comparisons:

### Test Cases Explained:

1. **`undefined !== obj.d;` (Test Name: undefined)**
   - This approach checks if the property `d` is defined by checking if its value is not `undefined`. 
   - **Pros**: Simple and straightforward; directly compares the value.
   - **Cons**: If the property `d` does not exist on the object, accessing `obj.d` will return `undefined`, which could lead to misleading results if a property exists but has an `undefined` value.

2. **`'undefined' !== typeof obj.d;` (Test Name: typeof)**
   - This test uses the `typeof` operator, which returns a string indicating the type of the unevaluated operand. If the property does not exist, `typeof` will return `'undefined'`.
   - **Pros**: Reliable for checking if a property exists because it distinguishes between properties that are not present and those that are present but have the value `undefined`.
   - **Cons**: Slightly more overhead than a direct comparison.

3. **`'d' in obj;` (Test Name: in)**
   - The `in` operator checks if a specified property is in an object or its prototype chain.
   - **Pros**: Accurate for determining if a property exists at all; works even if the property has a value of `undefined`.
   - **Cons**: Could be less performant if the prototype chain is deep, although in this case, it’s negligible.

4. **`Object.hasOwn(obj, 'd');` (Test Name: hasOwn)**
   - This is a method introduced in ES2022 that checks if the object has the property as its own property, meaning it won’t check the prototype chain.
   - **Pros**: Very accurate for checking only the object's own properties; avoids unintended checks on prototypes.
   - **Cons**: Slightly less performant compared to simple checks; may not be available in older browsers that do not support ES2022.

5. **`!! obj.d;` (Test Name: bool)**
   - This approach uses a double negation to convert the value of `obj.d` into a boolean (`true` if the property exists with a truthy value, `false` otherwise).
   - **Pros**: Quick check which can also be useful for validating if the property is `truthy`.
   - **Cons**: Only indicates presence if the property has a truthy value; does not differentiate between non-existence and existing properties with falsy values (like `0`, `false`, `null`).

### Benchmark Results:
The results of the benchmark indicate how many times each test can be executed per second in a particular environment:

- The `in` operator performed the best at **75,347,056 executions per second**.
- `bool` came in second with **74,814,464 executions**.
- `typeof` was next with **67,513,528 executions**.
- The `undefined` check followed with **59,567,128 executions**.
- Finally, `hasOwn` was the slowest at **40,237,600 executions**.

### Summary of Pros and Cons:
- **Performance**: The `in` operator and `!!` checks are the fastest, while `hasOwn` is the slowest.
- **Correctness**: `typeof`, `in`, and `hasOwn` provide more accurate indications of property existence, especially in cases where properties might be present but have the value `undefined`.
- **Use Case Suitability**: Depending on the context (whether one cares about prototype properties or just own properties), the choice of method will vary.

### Other Alternatives:
Other alternatives to check for property existence might include:
- Using libraries like Lodash which provide utility methods for property checks, although they may incur additional overhead.
- Performance optimization can be optimized by caching results or using more declarative patterns if the object is static.

Choosing the right approach depends on the specific application needs, priority on performance, and the handling aspect of property values in JavaScript.

Related benchmarks:

undefined vs. typeof vs. in vs. hasOwn (version: 1)

Object lookup performance

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

Created: 3 months ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwn

bool

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):