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;
Optional chaining
undefined !== obj?.d;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwnProperty
bool
Optional chaining

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The MeasureThat.net benchmark tests the performance of various JavaScript operators for object lookup: `undefined`, `typeof`, `in`, `hasOwnProperty`, and optional chaining (`?.`). The benchmark compares these different approaches to check if a property exists in an object.

**Operators Compared**

1. **`undefined`**: Checks if a variable is equal to `undefined`.
2. **`typeof`**: Returns the type of a variable (e.g., "number", "string", etc.).
3. **`in`**: Checks if a property exists in an object using the `in` operator.
4. **`hasOwnProperty`**: Checks if an object has a specified property as its own property, rather than inheriting it from its prototype chain.
5. **Optional chaining (`?.`)**: A new feature introduced in JavaScript (ECMAScript 2020) that allows safe navigation of nested properties.

**Pros and Cons**

* **`undefined`**: Simple and straightforward but can be slow for large objects or complex lookups.
	+ Pros: Easy to implement, high-level abstraction.
	+ Cons: May not work as expected if the object is not initialized properly.
* **`typeof`**: Fast and efficient but returns the type of a variable, not just whether it exists.
	+ Pros: Quick execution time, useful for type checking.
	+ Cons: Returns additional information that may not be relevant to the lookup operation.
* **`in`**: Fast and reliable but has limitations (e.g., does not work with `undefined` values).
	+ Pros: Fast execution time, works well for simple lookups.
	+ Cons: May produce false positives if the object is not properly initialized.
* **`hasOwnProperty`**: Reliable and precise but slower than `in`.
	+ Pros: Works correctly even when the object's prototype chain is involved.
	+ Cons: Slower execution time due to additional checks.
* **Optional chaining (`?.`)**: Safe and efficient but relatively new feature (ECMAScript 2020).
	+ Pros: Ensures safe navigation of nested properties, fast execution time.
	+ Cons: Requires support for ECMAScript 2020 or later.

**Library**

None explicitly mentioned in the benchmark definition. However, `obj` is an object literal created using JavaScript syntax, which implies that no external library was used to create it.

**Special JS Features/Syntax**

No special features or syntax are mentioned in the provided benchmark.

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 97 on Windows

View result in a separate tab

Test name	Executions per second
undefined	4906870.0 Ops/sec
typeof	12900414.0 Ops/sec
in	12776914.0 Ops/sec
hasOwnProperty	11837059.0 Ops/sec
bool	12895552.0 Ops/sec
Optional chaining	4879955.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 Optional chaining

Created: 2 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

bool

Optional chaining

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