Benchmark: ?. operator vs. getProperty

Tests:

?. operator (results in defined value)
const obj = { a: { b: { c: { exists: true } } } }; const exists = obj?.a?.b?.c?.exists;
?. operator (results in undefined value)
const obj = { a: { b: { c: { exists: true } } } }; const exists = obj?.a?.b?.c?.d?.e?.f?.g?.exists;
getProperty (results in defined value)
function getProperty(obj, ...path) { if (typeof obj !== 'object' || obj === null) { return undefined; } if (path.length === 0) { return obj; } let current = obj; for (let index = 0; index < path.length; index += 1) { current = current[path[index]]; // If there is more path to traverse but the current value is not traversable, quit. const isArray = Array.isArray(current); const isObject = !isArray && typeof current === 'object' && current !== null; if (!isObject && !isArray && (index + 1) < path.length) { return undefined; } } return current; } const obj = { a: { b: { c: { exists: true } } } }; const exists = getProperty(obj, 'a', 'b', 'c', 'exists');
getProperty (results in undefined value)
function getProperty(obj, ...path) { if (typeof obj !== 'object' || obj === null) { return undefined; } if (path.length === 0) { return obj; } let current = obj; for (let index = 0; index < path.length; index += 1) { current = current[path[index]]; // If there is more path to traverse but the current value is not traversable, quit. const isArray = Array.isArray(current); const isObject = !isArray && typeof current === 'object' && current !== null; if (!isObject && !isArray && (index + 1) < path.length) { return undefined; } } return current; } const obj = { a: { b: { c: { exists: true } } } }; const exists = getProperty(obj, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'exists');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
?. operator (results in defined value)
?. operator (results in undefined value)
getProperty (results in defined value)
getProperty (results in undefined value)

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 llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

The benchmark is testing two approaches to access nested properties of an object: using the optional chaining operator (`?.`) and a custom `getProperty` function.

**Optional Chaining Operator (`?.`)**

The optional chaining operator is a new feature in JavaScript introduced in ECMAScript 2020. It allows you to access nested properties of an object without throwing an error if any of the intermediate steps are null or undefined.

Example:
```javascript
const obj = { a: { b: { c: { exists: true } } } };
const exists = obj?.a?.b?.c?.exists; // returns true if exists is defined, otherwise undefined
```
The benchmark tests two scenarios:

1. When the nested property `exists` is defined (`obj?.a?.b?.c?.exists`), the operator should return a defined value.
2. When the nested property `exists` is not defined (e.g., due to an extra key like `d` in the object), the operator should return undefined.

**Custom `getProperty` Function**

The custom function `getProperty` takes an object and a path as arguments. It traverses the object using the path, checking if each intermediate step is null or undefined. If it encounters an undefined value, it immediately returns undefined.

Example:
```javascript
function getProperty(obj, ...path) {
  // ...
}

const obj = { a: { b: { c: { exists: true } } } };
const exists = getProperty(obj, 'a', 'b', 'c', 'exists'); // returns true if exists is defined, otherwise undefined
```
The benchmark tests two scenarios:

1. When the nested property `exists` is defined (`getProperty(obj, 'a', 'b', 'c', 'exists')`), the function should return a defined value.
2. When the nested property `exists` is not defined (e.g., due to an extra key like `d` in the object), the function should return undefined.

**Comparison and Pros/Cons**

Both approaches have their pros and cons:

* **Optional Chaining Operator (`?.`)**
	+ Pros:
		- Concise and readable syntax
		- Reduces code duplication for common cases
		- Faster performance (since it can short-circuit the traversal)
	+ Cons:
		- May lead to less predictable behavior if not used carefully
		- Limited control over error handling
* **Custom `getProperty` Function**
	+ Pros:
		- More control over error handling and behavior
		- Allows for custom logic to handle edge cases
	+ Cons:
		- Less concise syntax
		- May require more code duplication for common cases

**Other Considerations**

The benchmark also measures the execution speed of each approach, which can be influenced by factors like:

* Browser or environment performance
* Object complexity and size
* Path length and nesting depth

When choosing between these approaches, consider the trade-off between conciseness, readability, and control over behavior. If you need more predictability and flexibility, the custom `getProperty` function might be a better choice. Otherwise, the optional chaining operator (`?.`) can simplify your code and improve performance in most cases.

As for the benchmark results, they show that:

* The optional chaining operator (`?.`) is generally faster than the custom `getProperty` function.
* The custom `getProperty` function provides more control over error handling and behavior, but at a slightly higher cost in terms of execution speed.

Related benchmarks:

?. operator vs. getProperty (version: 0)

Comparing performance of: ?. operator (results in defined value) vs ?. operator (results in undefined value) vs getProperty (results in defined value) vs getProperty (results in undefined value)

Created: 4 years ago by: Guest

Jump to the latest result

?. operator (results in defined value)

?. operator (results in undefined value)

getProperty (results in defined value)

getProperty (results in undefined value)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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