Benchmark: Optional Chaining versus _.get lodash and with array

Script Preparation code:

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

Tests:

Optional Chaining
(obj.a == null ? undefined : obj.a.b == null ? undefined : obj.a.b.c == null ? undefined : obj.a.b.c.d) || 2 (badObj.a == null ? undefined : badObj.a.b == null ? undefined : badObj.a.b.c == null ? undefined : badObj.a.b.c.d) || 2
Lodash
_.get(obj, "a.b.c.d", 2) _.get(badObj, "a.b.c.d", 2)
Lodash array
_.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
Lodash array

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36

Browser/OS: Chrome 101 on Windows

View result in a separate tab

Test name	Executions per second
Optional Chaining	1224928.0 Ops/sec
Lodash	576112.9 Ops/sec
Lodash array	755075.3 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 benchmark and its components.

**Benchmark Definition JSON**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. It defines three test cases:

1. **Optional Chaining**: This test case compares the performance of using optional chaining (`?.`) in JavaScript to access nested object properties.
2. **Lodash**: This test case measures the execution time of using Lodash's `_.get()` method to access nested object properties.
3. **Lodash array**: This test case is similar to the previous one, but uses an array as the second argument instead of a string.

**Script Preparation Code**

The script preparation code provides the initial data objects used in the benchmark:
```javascript
var obj = {a: {b: {c: {d: 1}}}};
var badObj = {};
```
These two variables, `obj` and `badObj`, are used as test subjects for the benchmark.

**Options Compared**

In each test case:

* **Optional Chaining**: The code uses optional chaining (`?.`) to access nested object properties. This is a syntax introduced in ECMAScript 2020 (ES12) that allows for more concise way of accessing nested objects.
* **Lodash**: Lodash's `_.get()` method is used to access nested object properties. This method provides a functional programming approach to accessing nested objects.
* **Lodash array**: Similar to the previous case, but uses an array as the second argument instead of a string.

**Pros and Cons**

Here are some pros and cons for each approach:

* **Optional Chaining**:
	+ Pros: More concise syntax, easy to read and write, works well with modern JavaScript engines.
	+ Cons: May have performance overhead due to parsing and execution of the optional chaining expression.
* **Lodash**:
	+ Pros: Provides a consistent and predictable way of accessing nested objects, can be used for more complex data structures.
	+ Cons: Adds an extra library dependency, may not be as performant as native JavaScript implementations.
* **Lodash array**:
	+ Pros: Similar to the previous case, but uses an array instead of a string. This can provide better performance due to the optimized implementation of arrays in modern JavaScript engines.
	+ Cons: May require more careful handling of edge cases and array indexing.

**Other Considerations**

When interpreting these results, keep in mind that:

* The `ExecutionsPerSecond` value is an estimate of how many times each benchmark was executed per second on a particular device. This can provide insight into the performance characteristics of each implementation.
* The raw UA string (User Agent) and browser information are provided to give context about the testing environment.

**Alternatives**

If you're interested in exploring alternative approaches, consider:

* **Using a more performant JavaScript engine**: Some JavaScript engines, like V8 or SpiderMonkey, provide optimized implementations of various syntax features.
* **Implementing your own optional chaining**: If you need more control over the implementation, you can create your own optional chaining function using techniques like parsing and execution optimization.
* **Exploring other libraries or frameworks**: Depending on your specific use case, you may find that another library or framework provides a better solution for accessing nested objects.

Related benchmarks:

Optional Chaining versus _.get lodash and with array (version: 0)

Comparing performance of: Optional Chaining vs Lodash vs Lodash array

Created: 2 years ago by: Guest

Jump to the latest result

Optional Chaining

Lodash

Lodash array

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