Benchmark: lodash's 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 obj = {a: {b: {c: {d: 1}}}}
var badObj = {}

Tests:

Optional Chaining (?.)
const test1 = obj?.a?.b?.c?.d ?? null; const test2 = badObj?.a?.b?.c?.d ?? null;
Lodash _.get()
const test1 = _.get(obj, "a.b.c.d", null); const test2 = _.get(badObj, "a.b.c.d", null);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Optional Chaining (?.)
Lodash _.get()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36

Browser/OS: Chrome 89 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Optional Chaining (?.)	7693135.5 Ops/sec
Lodash _.get()	1327074.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 definition and test cases.

**Benchmark Definition**

MeasureThat.net is comparing two approaches to accessing nested properties in JavaScript objects: optional chaining (`?.`) and Lodash's `_.get()` method.

Optional chaining allows you to access nested properties of an object without directly creating a reference to them. If any part of the chain does not exist, it will return `undefined` instead of throwing an error. The syntax is as follows:
```javascript
obj?.a?.b?.c?.d ?? null;
```
This will check if `obj` has a property `a`, and if so, then checks if `a` has a property `b`, and so on. If any step fails, it will return `null`.

Lodash's `_get()` method is a utility function that allows you to access nested properties of an object in a similar way:
```javascript
_.get(obj, "a.b.c.d", null);
```
This will also follow the same chain as optional chaining.

**Options Compared**

The benchmark is comparing two options:

1. **Optional Chaining (`?.`)**: This approach uses the `?.` syntax to access nested properties.
2. **Lodash's `_get()` method**: This is a utility function provided by Lodash that allows you to access nested properties using a similar syntax.

**Pros and Cons**

Here are some pros and cons of each approach:

### Optional Chaining (`?.`)

Pros:

* More concise syntax
* Easier to read and write
* Can be more efficient since it avoids creating intermediate references

Cons:

* May not be supported in older browsers or environments that don't understand the `?.` syntax
* Can lead to confusing code if not used carefully (e.g., using `?.` with a large chain can make the code harder to read)

### Lodash's `_get()` method

Pros:

* Wide support across modern browsers and environments
* Provides more flexibility and customization options compared to optional chaining
* Can be used in older environments that don't understand `?.`

Cons:

* More verbose syntax
* May lead to slower performance due to the overhead of the `_get()` function call

**Other Considerations**

When choosing between these two approaches, consider the following factors:

* **Readability**: If you need to write a large chain of nested properties, optional chaining might be more readable. However, if you're working with complex logic or need more control over the process, Lodash's `_get()` method might be a better choice.
* **Performance**: Both approaches have similar performance characteristics, but Lodash's `_get()` method may incur some overhead due to the function call.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like string manipulation, array and object manipulation, and more. The `_.get()` method is one of its many utility functions, designed to help you access nested properties of objects in a concise and readable way.

**Special JS Feature: Optional Chaining (`?.`)**

Optional chaining was introduced in JavaScript ES2020 as part of the ECMAScript standard. It allows you to access nested properties of an object without directly creating a reference to them, which can help prevent errors and make code more concise.

In summary, MeasureThat.net is comparing two approaches to accessing nested properties in JavaScript objects: optional chaining (`?.`) and Lodash's `_get()` method. Both have their pros and cons, but optional chaining offers a more concise syntax with better readability, while Lodash's `_get()` method provides more flexibility and customization options at the cost of additional verbosity.

As for alternatives to these approaches, some other options you might consider include:

* **Using a different library**: There are many other JavaScript utility libraries available that offer similar functionality to Lodash.
* **Writing your own function**: If you need the specific behavior provided by optional chaining or `_get()`, you can write your own function using standard JavaScript syntax.
* **Using other ES2020 features**: In addition to optional chaining, there are several other ES2020 features you can use to access nested properties, such as template literals and destructuring.

Related benchmarks:

lodash's get vs optional chaining (?.) (version: 0)

Comparing performance of: Optional Chaining (?.) vs Lodash _.get()

Created: 3 years ago by: Guest

Jump to the latest result

Optional Chaining (?.)

Lodash _.get()

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