Benchmark: undefined vs. typeof vs. in vs. hasOwnProperty vs. Optional chaining

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;
?.
obj?.d

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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**What is being tested?**

MeasureThat.net is testing the performance of different approaches to access and compare properties of an object in a JavaScript environment.

**Options compared:**

The benchmark compares six different options:

1. `undefined` vs. literal value (e.g., `"d"`)
2. `typeof` vs. literal value (e.g., `'d'`)
3. `in` vs. property existence check
4. `hasOwnProperty` vs. property existence check
5. Optional chaining (`?.`) vs. explicit property access
6. Boolean negation (`!!`) vs. simple property access

**Pros and Cons of each approach:**

1. **Undefined**: This approach uses a literal value to represent the non-existent property. Pros: Simple, easy to understand. Cons: May lead to performance issues due to unnecessary type checking.
2. **typeof**: This approach uses the `typeof` operator to check if a variable is an object with a `d` property. Pros: More robust than `undefined`, but still slower than some other approaches. Cons: May not work as expected for non-object values.
3. **in**: This approach uses the `in` operator to check if a variable is present in an object. Pros: Fast, simple, and widely supported. Cons: May lead to false positives or negatives due to object property behavior.
4. **hasOwnProperty**: Similar to `in`, but only checks for direct properties of the object. Pros: More accurate than `in` for objects with nested properties. Cons: Slower than `in`.
5. **Optional chaining (?.)**: This approach uses the optional chaining operator (`?.`) to access a property without throwing an error if it doesn't exist. Pros: Fast, safe, and modern. Cons: Requires ES6+ support.
6. **Boolean negation**: This approach uses double exclamation marks (`!!`) to negate a boolean value before accessing a property. Pros: Simple, easy to understand. Cons: May lead to performance issues due to unnecessary type checking.

**Library usage:**

The benchmark does not explicitly use any libraries, but it may be relying on some built-in JavaScript features or behaviors that could be considered part of the language specification (e.g., `in`, `hasOwnProperty`).

**Special JS feature/syntax:**

Optional chaining (`?.`) is a relatively new feature introduced in ES6+ syntax. It allows safe navigation through objects without throwing errors.

Other alternatives:

* **Bracket notation**: Instead of using `in` or `hasOwnProperty`, you could use bracket notation (`obj['d']`) to access properties dynamically.
* **Property access with `[]`**: Similar to bracket notation, you could use property access with square brackets (`obj['d']`) for dynamic property access.

Keep in mind that these alternatives may have different performance characteristics and are not necessarily equivalent to the approaches tested in this benchmark.

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
undefined	1700237.0 Ops/sec
typeof	5266003.5 Ops/sec
in	5793627.5 Ops/sec
hasOwnProperty	4974282.0 Ops/sec
bool	5179799.0 Ops/sec
?.	5058121.0 Ops/sec

Related benchmarks:

undefined vs. typeof vs. in vs. hasOwnProperty vs. Optional chaining (version: 0)

Object lookup performance

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

Created: 3 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

bool

?.

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