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.

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.

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.

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.

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.