Benchmark: lodash get vs nullish coalescing

HTML Preparation code:

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

Script Preparation code:

var result = '';

var data = {
    data: [
        {
            user: {
                location: {
                    address: {
                        street: 'main street',
                    },
                },
            },
               
        },
    ],
};

const iterations = 100;

Tests:

get existing property
for (let i = 0; i < 100; i += 1) { result = _.get(data, 'data.0.user.location.address.street', ''); }
null coalescing existing property
for (let i = 0; i < 100; i += 1) { result = data?.data?.[0]?.user?.location?.address?.street ?? ''; }
get non existing property
for (let i = 0; i < 100; i += 1) { result = _.get(data, 'data.0.user.location.address.zip', ''); }
null coalescing non existing property
for (let i = 0; i < 100; i += 1) { result = data?.data?.[0]?.user?.location?.address?.zip ?? ''; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
get existing property
null coalescing existing property
get non existing property
null coalescing non existing property

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 break down the provided JSON and explain what is tested on MeasureThat.net.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The website provides a simple way for developers to compare the performance of different approaches to achieve similar results in their code.

**Benchmark Definition**

The benchmark definition represents the test case being measured. In this case, we have four individual test cases:

1. `get existing property`: This test checks the performance of accessing an existing property using the Lodash `_.get()` method.
2. `null coalescing existing property`: This test checks the performance of using null coalescing (`??`) to access an existing property.
3. `get non existing property`: This test checks the performance of accessing a non-existent property using the Lodash `_.get()` method.
4. `null coalescing non existing property`: This test checks the performance of using null coalescing (`??`) to access a non-existent property.

**Options Compared**

The four test cases compare two approaches:

1. **Lodash `_get()` method**: A popular utility function for accessing nested properties in objects.
2. **Null Coalescing Operator (`??`)**: A syntax feature introduced in ECMAScript 2020 that returns the first operand if it's not null or undefined, and the second operand otherwise.

**Pros and Cons of Each Approach**

Here are some pros and cons of each approach:

1. **Lodash `_get()` method**:
	* Pros:
		+ More readable code (explicitly accessing nested properties).
		+ Handles missing properties by returning a default value.
	* Cons:
		+ Requires Lodash library, which can add overhead due to minification and compression.
		+ Can be slower than using the null coalescing operator if the property is not accessed frequently.
2. **Null Coalescing Operator (`??`)**:
	* Pros:
		+ More concise code (one line of syntax).
		+ Does not require a separate library or function call overhead.
	* Cons:
		+ Less readable code ( implicit behavior can be confusing).
		+ May return `undefined` if both operands are null or undefined, which may not be the desired behavior in all cases.

**Other Considerations**

When choosing between these two approaches, consider the following factors:

1. **Code readability**: If you prioritize clear and concise code, using the null coalescing operator might be a better choice. However, if readability is more important than brevity, using the Lodash `_get()` method might be a better fit.
2. **Performance**: In most cases, the performance difference between these two approaches will be negligible. However, if you're working with large datasets or performance-critical code, using the null coalescing operator might result in slightly better performance due to reduced overhead from function calls and library imports.

**Other Alternatives**

If you don't want to use Lodash or the null coalescing operator, you can also consider alternative approaches:

1. **Destructuring assignment**: You can use destructuring assignment to access nested properties, like this: `const { location: { address: { street } } } = data.data[0].user`.
2. **Optional chaining (`?.`)**: This syntax was introduced in ECMAScript 2020 and allows accessing nested properties while handling null or undefined values. For example: `data?.data?.[0]?.user?.location?.address?.street`.

Keep in mind that these alternatives might have different performance characteristics than the null coalescing operator, so you should test them to determine which one is best for your specific use case.

Overall, MeasureThat.net provides a useful tool for comparing the performance of different approaches to accessing nested properties and using null-coalescing operators. By understanding the pros and cons of each approach, you can make informed decisions about which one to use in your own code.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
get existing property	17854.3 Ops/sec
null coalescing existing property	57370.4 Ops/sec
get non existing property	16812.8 Ops/sec
null coalescing non existing property	57700.0 Ops/sec

Related benchmarks:

lodash get vs nullish coalescing (version: 0)

Comparing performance of: get existing property vs null coalescing existing property vs get non existing property vs null coalescing non existing property

Created: one year ago by: Registered User

Jump to the latest result

get existing property

null coalescing existing property

get non existing property

null coalescing non existing property

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