Benchmark: undefined vs. typeof vs. in vs. hasOwnProperty for non-existing property

Script Preparation code:

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

Tests:

undefined
undefined !== obj.f;
typeof
'undefined' !== typeof obj.f;
in
'f' in obj;
hasOwnProperty
obj.hasOwnProperty( 'f' );
bool
!! obj.f;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwnProperty
bool

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 137 on Windows

View result in a separate tab

Test name	Executions per second
undefined	84513224.0 Ops/sec
typeof	81563352.0 Ops/sec
in	76780584.0 Ops/sec
hasOwnProperty	43685760.0 Ops/sec
bool	77110256.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition**

The benchmark measures the performance of different ways to check if a non-existing property exists in an object, and whether the `typeof` operator can be used to distinguish between `undefined` and other values. Specifically, it compares:

1. Using the `in` operator (`"f" in obj;`)
2. Using the `hasOwnProperty()` method (`obj.hasOwnProperty('f');`)
3. Using the `typeof` operator (`'undefined' !== typeof obj.f;`)
4. Using a boolean cast (`!! obj.f;`)
5. Directly comparing with `undefined` (`undefined !== obj.f;`)

**Library and Special Features**

There is no external library used in this benchmark. However, it's worth noting that the `typeof` operator can return `undefined` if the variable is uninitialized or has been deleted.

**Options Compared**

The options compared are:

* Using the `in` operator to check if a property exists
* Using the `hasOwnProperty()` method to check if a property exists
* Using the `typeof` operator to distinguish between `undefined` and other values
* Using a boolean cast (`!!`) to convert a value to a boolean
* Directly comparing with `undefined`

**Pros and Cons**

Here's a brief summary of each option:

1. **in**: Pros: simple, fast, can be used for multiple properties. Cons: may not work for objects with prototype chains, can return true for own enumerable properties that are also inherited.
2. **hasOwnProperty()**: Pros: more robust than `in`, specifically designed for checking property existence on an object's prototype chain. Cons: slower than `in` and requires a method call.
3. **typeof**: Pros: fast, simple, works well for primitive types. Cons: may return incorrect results for objects (e.g., `undefined`), and can be slow for complex expressions.
4. **!!**: Pros: simple, fast, works well for boolean values. Cons: requires a cast operation, which can be slower than direct comparisons.
5. **Direct comparison with undefined**:

Pros: clear and straightforward.

Cons: may not work if the property is initialized as `undefined` (e.g., due to default values or other side effects).

**Benchmark Results**

The latest benchmark results show that:

* `typeof` is the fastest option, followed closely by `!!`.
* The `in` operator and `hasOwnProperty()` method are slower but still relatively fast.
* Direct comparison with `undefined` is the slowest option.

These results may vary depending on the specific use case, object structure, and browser performance.

**Alternatives**

If you're looking for alternative approaches or have specific requirements, consider:

1. **Using the `in` operator with a try-catch block**: This can help handle cases where the property doesn't exist.
2. **Implementing your own check**: If performance is critical, consider implementing a custom check using bitwise operations or other techniques.
3. **Using other methods for object iteration**: Depending on your use case, you may want to explore other methods like `for...in` loops, `Object.keys()`, or `Object.values()`.

Keep in mind that the best approach depends on your specific requirements and constraints.

Related benchmarks:

undefined vs. typeof vs. in vs. hasOwnProperty for non-existing property (version: 0)

Object lookup performance

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

Created: 5 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

bool

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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