Benchmark: Native Optional Chaining plus Nullish Coalescing versus _.get lodash

Script Preparation code:

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

Tests:

Optional Chaining
const c = obj?.a?.b?.c?.d ?? 2 const d = 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: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0

Browser/OS: Firefox 99 on Windows

View result in a separate tab

Test name	Executions per second
Optional Chaining	33505620.0 Ops/sec
Lodash	1816661.9 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is designed to compare two approaches:

1. **Native Optional Chaining**: This approach uses the optional chaining operator (`?.`) in JavaScript to access nested properties of an object.
2. **Lodash's _.get() method**: This approach uses Lodash, a popular utility library for JavaScript, which provides a `_.get()` method to safely navigate objects and handle missing properties.

**Script Preparation Code**

The script preparation code defines two objects: `obj` and `badObj`. `obj` is an object with nested properties, while `badObj` is an empty object. The purpose of these objects is to simulate real-world scenarios where optional chaining or _.get() might be used.

**Benchmark Test Cases**

There are two test cases:

1. **Optional Chaining**: This test case uses the native optional chaining operator (`?.`) to access nested properties of `obj` and `badObj`. The goal is to measure how fast this approach can access the value at `d`.
2. **Lodash's _.get() method**: This test case uses Lodash's `_.get()` method to safely navigate objects `obj` and `badObj` to access the value at `d`.

**Pros and Cons of Each Approach**

**Native Optional Chaining**

Pros:

* Fast and lightweight, as it only requires a single operator (`?.`)
* Easy to use and understand
* Native support in modern JavaScript engines

Cons:

* May not work with all object types or structures (e.g., arrays, sets)
* Can lead to null pointer exceptions if the chained properties are missing

**Lodash's _.get() method**

Pros:

* Robust and flexible, as it can handle various object types and structures
* Safe by default, catching null pointer exceptions and providing a fallback value (in this case, `2`)

Cons:

* Additional dependency on Lodash, which may add overhead
* More complex and harder to understand compared to native optional chaining

**Other Considerations**

When comparing these approaches, it's essential to consider the following factors:

* **Performance**: Native optional chaining is generally faster due to its lightweight nature. However, Lodash's _.get() method can still provide benefits if you need to handle more complex object navigation or want a safer approach.
* **Code readability and maintainability**: Native optional chaining is often easier to understand and write, while Lodash's _.get() method may require more setup and understanding of the utility library.

**Alternative Approaches**

If you don't want to use either native optional chaining or Lodash's _.get() method, you can consider other alternatives, such as:

* Using a custom function with conditional checks for null pointer exceptions
* Employing a third-party library like Moment.js (for date and time management) or jQuery (for DOM manipulation)
* Implementing your own solution using loops and conditional statements

Keep in mind that each alternative approach will have its pros and cons, and it's essential to evaluate the trade-offs based on your specific use case and requirements.

Related benchmarks:

Native Optional Chaining plus Nullish Coalescing versus _.get lodash (version: 0)

Comparing performance of: Optional Chaining vs Lodash

Created: 3 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 2 months ago):