Benchmark: ES2020 Optional Chaining versus _.get lodash

Script Preparation code:

var obj = {a: {b: {c: {d: 1}}}}
var badObj = {}

Tests:

Optional Chaining
obj?.a?.b?.c?.d || 2 badObj?.a?.b?.c?.d || 2
Lodash
_.get(obj, "a.b.c.d", 2) _.get(badObj, "a.b.c.d", 2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Optional Chaining
Lodash

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36

Browser/OS: Chrome 121 on Linux

View result in a separate tab

Test name	Executions per second
Optional Chaining	15479970.0 Ops/sec
Lodash	3444905.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The current benchmark measures the performance of two approaches: ES2020 Optional Chaining (`?.`) versus Lodash's `_.get` method. The goal is to determine which approach is faster for accessing nested properties in objects.

**ES2020 Optional Chaining**

ES2020 introduced a new operator called optional chaining (`?.`). It allows you to access nested properties in an object without throwing a `NaN` or returning `undefined` if any of the intermediate steps are `null` or `undefined`. The syntax is as follows:
```javascript
obj?.a?.b?.c?.d // returns d if obj is not null or undefined, otherwise returns NaN or 0 (default)
```
**Lodash's `_get` method**

Lodash's `_get` method is a utility function that allows you to access nested properties in objects. The syntax is as follows:
```javascript
_.get(obj, "a.b.c.d", 2) // returns d if obj is not null or undefined, otherwise returns 2 (default)
```
**Comparison**

The benchmark tests the performance of both approaches on two test cases:

1. `obj?.a?.b?.c?.d || 2` (ES2020 Optional Chaining)
2. `.get(obj, "a.b.c.d", 2)` (Lodash's `_get` method)

In both test cases, if the intermediate steps are `null` or `undefined`, the function returns a default value (`2` in this case).

**Pros and Cons**

**ES2020 Optional Chaining:**

Pros:

* Concise syntax
* More expressive and readable code
* Built-in support in modern JavaScript engines (Chrome 121 and later)

Cons:

* May lead to confusing code if not used carefully
* Not supported by older browsers or environments

**Lodash's `_get` method:**

Pros:

* Well-established and widely adopted library
* Provides a clear and consistent API for accessing nested properties
* Supports older browsers and environments

Cons:

* Adds extra overhead due to the library call
* May require additional imports and setup

**Other Considerations**

When choosing between ES2020 Optional Chaining and Lodash's `_get` method, consider the following factors:

* Development speed and readability: If you need to access nested properties frequently, optional chaining may be a better choice for its concise syntax and expressiveness.
* Compatibility: If you need to support older browsers or environments, Lodash's `_get` method may be a safer choice.

**Alternatives**

If you're not convinced about using ES2020 Optional Chaining or Lodash's `_get` method, consider the following alternatives:

1. **Use the `in` operator**: Instead of accessing nested properties with optional chaining or Lodash's `_get`, use the `in` operator to check if a property exists before attempting to access it.
```javascript
if ("a" in obj && "b" in obj.a && "c" in obj.b.a) {
  console.log(obj.b.a.c);
}
```
2. **Use a utility library**: If you need to perform complex nested property accesses frequently, consider using a dedicated utility library like Lodash or a similar alternative.

In summary, the benchmark highlights the performance difference between ES2020 Optional Chaining and Lodash's `_get` method for accessing nested properties in objects. While both approaches have their pros and cons, the choice ultimately depends on your specific use case, development speed, and compatibility requirements.

Related benchmarks:

ES2020 Optional Chaining versus _.get lodash (version: 0)

Comparing performance of: Optional Chaining vs Lodash

Created: 4 years ago by: Guest

Jump to the latest result

Optional Chaining

Lodash

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