Benchmark: Lodash get vs. native solutions

HTML Preparation code:

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

Tests:

_,get, sloppy
const props = { stops: [ { location: { address: '123 Main Street', }, }, ], }; for (let i = 0; i < 50; i++) { const address = _.get(props, 'stops[0].location.address'); }
_.get, smarter
const props = { stops: [ { location: { address: '123 Main Street', }, }, ], }; for (let i = 0; i < 50; i++) { const address = _.get(props.stops[0].location, 'address'); }
native, no protection
const props = { stops: [ { location: { address: '123 Main Street', }, }, ], }; for (let i = 0; i < 50; i++) { const address = props.stops[0].location.address; }
native, some protection
const props = { stops: [ { location: { address: '123 Main Street', }, }, ], }; for (let i = 0; i < 50; i++) { const address = props.stops && props.stops[0].location.address; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_,get, sloppy
_.get, smarter
native, no protection
native, some protection

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark compares four approaches to accessing an object property in JavaScript:

1. Using Lodash's `_.get()` method
2. Using Lodash's `_.get()` method with a "smarter" approach (not specified in the documentation)
3. Directly accessing the property using dot notation (`native, no protection`)
4. Directly accessing the property using dot notation, but checking for existence before accessing (`native, some protection`)

**Lodash `_get()` Method**

The Lodash library is a popular utility library that provides various helper functions for tasks such as string manipulation, array and object manipulation, and more. The `_.get()` method is used to safely access nested properties in an object.

In the benchmark, Lodash's `_.get()` method is used in two ways:

* With "sloppy" syntax: `const address = _.get(props, 'stops[0].location.address');`
* With a "smarter" approach (not specified in the documentation): `const address = _.get(props.stops[0].location, 'address');`

The pros of using Lodash's `_get()` method include:

* Providing a safe and efficient way to access nested properties
* Handling edge cases such as null or undefined values

However, there are also some cons:

* Introducing additional overhead due to the library call
* Potentially introducing additional complexity in complex data structures

**Direct Access with Dot Notation**

The "native, no protection" approach uses direct dot notation to access the property:
```javascript
const address = props.stops[0].location.address;
```
This approach is simple and straightforward but may not be as safe or efficient as using Lodash's `_get()` method.

Pros:

* Minimal overhead due to no library call
* Simple and easy to read code

Cons:

* May throw errors if the property does not exist or is null/undefined
* May not handle edge cases such as nested properties

**Direct Access with Dot Notation and Existence Check**

The "native, some protection" approach uses direct dot notation but adds an existence check:
```javascript
const address = props.stops && props.stops[0].location.address;
```
This approach balances the simplicity of direct dot notation with the safety of checking for existence before accessing.

Pros:

* Minimal overhead due to no library call
* Adds safety by checking for existence before accessing

Cons:

* May not be as efficient as using Lodash's `_get()` method due to the additional existence check
* May not handle edge cases such as nested properties

**Other Alternatives**

If you need to access nested properties in JavaScript, other alternatives include:

* Using bracket notation (e.g., `props['stops[0].location.address']`)
* Using a recursive function to traverse the object structure
* Using a library like Immutable.js or deep-object to handle complex data structures

However, these alternatives may introduce additional complexity and overhead compared to using Lodash's `_get()` method.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_,get, sloppy	157230.9 Ops/sec
_.get, smarter	255572.5 Ops/sec
native, no protection	10545897.0 Ops/sec
native, some protection	7809628.5 Ops/sec

Related benchmarks:

Lodash get vs. native solutions (version: 4)

Comparing performance of: _,get, sloppy vs _.get, smarter vs native, no protection vs native, some protection

Created: 5 years ago by: Registered User

Jump to the latest result

_,get, sloppy

_.get, smarter

native, no protection

native, some protection

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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