Benchmark: Lodash.get string vs array vs native at depth 2

HTML Preparation code:

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

Script Preparation code:

var person = {data: {type: 'Frederick'}};

Tests:

Lodash get string
_.get(person, 'data.type');
Lodash get array
const type = _.get(person, ['data', 'type']);
Native
const type = person.data.type
Native with checking for missing object
const data = person.data if(data !== null){ const type = data.type }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash get string
Lodash get array
Native
Native with checking for missing object

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 97 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash get string	2976911.2 Ops/sec
Lodash get array	4487002.0 Ops/sec
Native	17036738.0 Ops/sec
Native with checking for missing object	17072112.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares the performance of three approaches to access the `type` property within an object:

1. **Lodash**: A popular JavaScript utility library that provides a `get()` function for accessing nested properties.
2. **Native**: Directly accessing the `type` property using dot notation (`person.data.type`).
3. **Native with checking**: Adding a null check before accessing the `type` property (`const type = person.data !== null ? data.type : undefined;`).

**Comparison of Options**

* **Lodash**: Uses its `get()` function to access nested properties. This approach provides a convenient way to handle nested object structures, but may incur additional overhead due to the function call.
	+ Pros: Convenient and flexible for handling complex nested objects.
	+ Cons: May introduce unnecessary overhead due to function calls.
* **Native**: Directly accesses the `type` property using dot notation. This approach is simple and efficient, as it only requires a single property access.
	+ Pros: Simple and efficient, with minimal overhead.
	+ Cons: Requires explicit null checks for missing object properties.
* **Native with checking**: Adds a null check before accessing the `type` property. This approach balances the simplicity of the native approach with the safety of checking for missing object properties.
	+ Pros: Balances simplicity with safety, reducing the need for explicit null checks.
	+ Cons: Introduces additional overhead due to the null check.

**Library and Purpose**

* **Lodash**: A popular JavaScript utility library that provides a wide range of functions for tasks such as string manipulation, array processing, and object manipulation. The `get()` function is designed to handle nested property access in an elegant and flexible way.
* **Other libraries**: MeasureThat.net also tests other libraries, such as Underscore.js, Ramda, or Immutable.js, but they are not relevant to this specific benchmark.

**Special JS Features**

There are no special JavaScript features or syntaxes used in this benchmark. The focus is on comparing the performance of different approaches to access nested properties within an object.

**Alternatives**

If you're looking for alternative approaches to accessing nested properties in your code, consider the following:

* **Using a library**: Lodash or other libraries like Underscore.js or Ramda can provide convenient and flexible ways to handle nested property access.
* **Native approach with explicit null checks**: For simple cases where null checks are not necessary, using dot notation directly may be the most efficient option.
* **Immutable data structures**: If you're working with immutable data structures, you may be able to avoid unnecessary overhead by using functions that return new objects instead of modifying existing ones.

In conclusion, this benchmark provides a useful comparison of three approaches to accessing nested properties within an object: Lodash's `get()` function, native dot notation, and native with null checking. By understanding the pros and cons of each approach, you can make informed decisions about how to optimize your code for performance and readability.

Related benchmarks:

Lodash.get string vs array vs native at depth 2 (version: 0)

Comparing performance of: Lodash get string vs Lodash get array vs Native vs Native with checking for missing object

Created: 2 years ago by: Guest

Jump to the latest result

Lodash get string

Lodash get array

Native

Native with checking for missing object

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