Benchmark: Lodash.get vs Property dot notation nested accessor now working

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var something = { props: { user: { firstName: "Troy", lastName: "Aikman" } } };

Tests:

Lodash get
_.get(something.props, 'user.firstName');
Native
something.props.user ? something.props.user.firstName : undefined

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get
Native

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36

Browser/OS: Chrome 101 on Linux

View result in a separate tab

Test name	Executions per second
Lodash get	4585528.5 Ops/sec
Native	12126915.0 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 benchmark and explain what's being tested.

**What is being tested?**

The benchmark is comparing two ways to access nested properties in JavaScript: Lodash's `_.get()` method and native property access using dot notation.

**Lodash's _.get() method**

Lodash's `_.get()` method is a utility function that allows you to safely navigate nested objects. In the provided benchmark, it's used to access the `firstName` property of an object inside another object.

The syntax `_.get(something.props, 'user.firstName')` calls the `_.get()` method with two arguments: the first being the source object (`something.props`) and the second being a string representing the nested path (`'user.firstName'`). The method returns the value at that nested path.

**Native property access using dot notation**

The alternative approach is to use native property access using dot notation, as shown in the benchmark definition `something.props.user ? something.props.user.firstName :  undefined`. This syntax uses the optional chaining operator (`?.`) or the null coalescing operator (`?:`) to safely navigate nested properties.

**Options compared**

Two options are being compared:

1. Lodash's `_.get()` method
2. Native property access using dot notation

**Pros and cons of each approach**

**Lodash's _.get() method**

Pros:

* More explicit and readable syntax for navigating nested objects
* Can handle more complex nesting and even support multiple levels of nullability
* Often considered safer than native property access, as it handles errors explicitly

Cons:

* Adds extra overhead due to the function call and potential performance impact
* Requires Lodash library to be included in the benchmark (as shown in the HTML preparation code)

**Native property access using dot notation**

Pros:

* Faster performance, since it doesn't involve a function call or additional overhead
* Less overhead compared to using a dedicated utility function like Lodash's `_.get()`

Cons:

* Can lead to errors if the nested path is incorrect or the object is null
* May require more code to handle potential nullability and edge cases

**Library used**

In this benchmark, Lodash is being used. Lodash is a popular JavaScript library that provides utility functions for common tasks, including data manipulation, string manipulation, and more.

**Special JS feature or syntax**

The `?.` operator (optional chaining) and the `?:` operator (null coalescing) are special syntax features introduced in ECMAScript 2020. They allow you to safely navigate nested properties and handle potential nullability.

In this benchmark, both approaches use these special syntax features: Lodash's `_.get()` method implicitly uses the `?.` operator, while native property access uses the `?:` operator directly.

**Other alternatives**

If you wanted to measure alternative approaches for accessing nested properties in JavaScript, you might consider using other utility libraries like Underscore.js or Moment.js, or even native functions like `JSON.parse()` and `JSON.stringify()`. However, these would likely have different trade-offs and requirements compared to Lodash's `_.get()` method.

Keep in mind that this benchmark is specifically designed to compare the performance of Lodash's `_.get()` method with native property access using dot notation. If you wanted to explore other approaches, you'd need to create new benchmark definitions and configurations.

Related benchmarks:

Lodash.get vs Property dot notation nested accessor now working (version: 0)

Comparing performance of: Lodash get vs Native

Created: 5 years ago by: Guest

Jump to the latest result

Lodash get

Native

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