Benchmark: Lodash get vs optional chaining

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var pepe = {
  a: {
    b: null
  }
}

Tests:

Lodash get
for (var i = 0; i < 1000; i++) { var a = _.get(pepe, 'a.b.c.d'); }
Js native Optional Chaining
for (var i = 0; i < 1000; i++) { var a = pepe.a.b?.c?.d; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
Js native Optional Chaining

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 dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Overview**

The provided JSON represents a JavaScript microbenchmark that compares two approaches: Lodash's `get` method and JavaScript native optional chaining. The test case is designed to measure which approach performs better for accessing nested properties in an object.

**Script Preparation Code**

The preparation code defines an object `pepe` with a nested structure, where the ultimate goal is to access the property `c.d`. This setup allows us to create a meaningful benchmark scenario.

```javascript
var pepe = {
  a: {
    b: null
  }
};
```

**Html Preparation Code**

The HTML code includes a reference to Lodash's JavaScript library, which is used by the first test case. This library provides the `get` method that we're comparing with JavaScript native optional chaining.

```html
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
```

**Individual Test Cases**

There are two test cases:

1. **Lodash get**: This test case uses Lodash's `get` method to access the property `c.d`.
```javascript
for (var i = 0; i < 1000; i++) {
  var a = _.get(pepe, 'a.b.c.d');
}
```
2. **Js native Optional Chaining**: This test case uses JavaScript's native optional chaining feature to access the property `c.d`.
```javascript
for (var i = 0; i < 1000; i++) {
  var a = pepe.a.b?.c?.d;
}
```

**Pros and Cons of Each Approach**

* **Lodash get**: The pros are:
	+ Well-tested and widely adopted library.
	+ Provides a clear, explicit way to access nested properties.
	+ Can handle edge cases like null or undefined values.
*   The cons are:
    *   Requires an additional library download (Lodash).
    + May introduce unnecessary overhead due to the extra function call.

* **JavaScript native Optional Chaining**: The pros are:
    *   Built-in, so no additional library is required.
    + More lightweight and efficient compared to Lodash's `get` method.
    + Can be used with modern browsers that support this feature.
*   The cons are:
    *   Less explicit and readable than using a dedicated function like Lodash's `get`.
    + May not handle edge cases as robustly as Lodash's implementation.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functional programming helpers, including the `get` method. It's widely adopted and well-maintained, making it a reliable choice for many developers.

**Special JS Feature: Optional Chaining**

Optional chaining is a new feature in modern JavaScript (introduced in ECMAScript 2020) that allows you to access nested properties in an object using the `?.` operator. This feature was added to mitigate issues with null or undefined values during chain navigation, making it safer to traverse objects.

**Benchmark Result Interpretation**

The benchmark result shows two browsers running the test cases on a desktop device. The results indicate:

*   **Js native Optional Chaining**: This approach is faster and more efficient, executing approximately 17113.662109375 times per second.
*   **Lodash get**: This approach is slower, executing around 2894.665283203125 times per second.

These results suggest that JavaScript's native optional chaining feature is a viable alternative to using Lodash's `get` method for accessing nested properties in objects.

Related benchmarks:

Lodash get vs optional chaining (version: 0)

Comparing performance of: Lodash get vs Js native Optional Chaining

Created: 4 years ago by: Guest

Jump to the latest result

Lodash get

Js native Optional Chaining

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