Benchmark: lodash get vs native javascript

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/immer@3.1.3/dist/immer.umd.min.js"></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

state =  {
    data: {
      data1: {
        data2: 'test'
      }
    }
  };

Tests:

lodash get
const result = _.get(state, ['data', 'data1', 'data2'])
CloneDeep
const result = state?.data?.data1?.data2

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash get
CloneDeep

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's tested in this benchmark.

**Overview**

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks, which are small tests designed to measure the performance of specific code snippets. The benchmark provided consists of two test cases: "lodash get" and "CloneDeep".

**Benchmark Definitions**

The benchmark definitions describe the code snippets being tested. Let's break them down:

1. **lodash get**: This test case uses the Lodash library, a popular utility library for JavaScript. The `_.get()` method is used to safely access nested properties of an object. In this case, the code snippet attempts to access the value of `data2` within the `data1` property of the `state` object.
```javascript
const result = _.get(state, ['data', 'data1', 'data2']);
```
The Lodash library provides a convenient way to access nested properties without worrying about null or undefined values.

2. **CloneDeep**: This test case uses the Immer library, which is designed for efficient and predictable object mutations. The code snippet creates a deep copy of the `state` object using the `cloneDeep()` method.
```javascript
const result = state?.data?.data1?.data2;
```
In modern JavaScript, we can use optional chaining (`?.`) to access nested properties in a safe manner.

**Options Compared**

The benchmark compares two approaches:

1. **Lodash get**: This approach uses the `_.get()` method to access the nested property.
2. **CloneDeep**: This approach creates a deep copy of the object using Immer's `cloneDeep()` method.

Both approaches have their pros and cons:

* **Lodash get**:
	+ Pros: Easy to use, provides a convenient way to access nested properties without worrying about null or undefined values.
	+ Cons: Requires an external library (Lodash), may incur additional overhead due to the library's existence.
* **CloneDeep**:
	+ Pros: Native JavaScript implementation, avoids external library dependencies.
	+ Cons: Requires more manual effort to access nested properties safely.

In general, the CloneDeep approach is a good choice when working with native JavaScript and prefer not to rely on external libraries. However, Lodash get provides a convenient way to access nested properties without worrying about null or undefined values, making it a popular choice among developers.

**Other Considerations**

When choosing between these approaches, consider the following factors:

* **Performance**: Immer's `cloneDeep()` method is generally faster than using Lodash for simple property accesses.
* **Code readability**: If you're working on a complex project with many nested properties, Lodash get might be easier to read and maintain.
* **Library dependencies**: If you prefer not to use external libraries, CloneDeep is the way to go.

**Other Alternatives**

If you don't like using Lodash or Immer, there are alternative approaches:

1. **Manual property access**: You can use plain JavaScript to access nested properties without relying on any library.
```javascript
const result = state.data.data1.data2;
```
This approach requires more manual effort and may lead to null or undefined value checks.

2. **Using `Object.prototype.hasOwnProperty.call()`**: This method provides a safer way to check if an object has a certain property before accessing it.
```javascript
const result = (state.data && state.data.data1 && state.data.data1.data2);
```
This approach requires careful handling of nested properties and may not be as convenient as using Lodash or CloneDeep.

Overall, the choice between these approaches depends on your specific use case, performance requirements, and personal preference. MeasureThat.net's benchmark provides a useful insight into how these approaches compare in terms of execution speed and performance.

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/90.0.4430.72 Safari/537.36

Browser/OS: Chrome 90 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash get	2344650.0 Ops/sec
CloneDeep	5499033.5 Ops/sec

Related benchmarks:

lodash get vs native javascript (version: 0)

Comparing performance of: lodash get vs CloneDeep

Created: 3 years ago by: Guest

Jump to the latest result

lodash get

CloneDeep

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