Benchmark: Lodash set vs multiple destructuring

HTML Preparation code:

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

Script Preparation code:

var nestedObject = {
  level: {
    anotherLevel: {
      oneMoreLevel: {
        evenOnemore: {
          stringTest: 'foo'
        },
        sameOnSameLevel: 20
      }
    }
  }
}

Tests:

Lodash set
_.set(nestedObject, 'level.anotherLevel.oneMoreLevel.evenOnemore.stringTest', 'bar')
Native destructuring
nestedObject = { ...nestedObject, level: { ...nestedObject.level, anotherLevel: { ...nestedObject.level.anotherLevel, oneMoreLevel: { ...nestedObject.level.anotherLevel.oneMoreLevel, evenOnemore: { ...nestedObject.level.anotherLevel.oneMoreLevel.evenOnemore, stringTest: 'bar' } } } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash set
Native destructuring

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark definition and test cases.

**Benchmark Definition and Preparation Code**

The benchmark is defined using JSON, which represents a JavaScript microbenchmarking experiment. The preparation code for the benchmark is provided in two parts:

1. A nested JavaScript object (`nestedObject`) that serves as the input data for the benchmark.
2. A script tag that includes the Lodash library version 4.17.5.

**Options Being Compared**

The benchmark compares two approaches to set a value on an object:

1. **Lodash's `set` function**: The first test case uses the `_.set()` method from the Lodash library to update the `nestedObject`. This approach is likely slower because it involves a call to the external library.
2. **Native destructuring with nested objects**: The second test case uses native JavaScript destructuring syntax to create a new object with the updated values. This approach is likely faster because it leverages the optimized performance of native JavaScript.

**Pros and Cons**

Here are some pros and cons for each approach:

**Lodash's `set` function**

Pros:

* Concise and readable code
* Easy to maintain and understand
* Does not require knowledge of deep object manipulation

Cons:

* Slower due to external library call overhead
* May incur additional memory allocations or garbage collection

**Native destructuring with nested objects**

Pros:

* Faster execution speed due to native optimization
* Memory-efficient, as it avoids unnecessary allocations
* No external library dependencies

Cons:

* Requires knowledge of deep object manipulation and syntax nuances
* May be less readable or maintainable for some developers

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides various functions for data manipulation, array processing, and other tasks. The `set` function is one of its most useful tools for updating values in objects.

**Special JS Feature/Syntax**

There are no special JS features or syntax used in this benchmark. However, it's worth noting that the use of nested objects requires a good understanding of JavaScript object manipulation and recursion.

**Other Alternatives**

If you wanted to create similar benchmarks using alternative approaches, here are some options:

1. **Native destructuring with spread operators**: You could use the spread operator (`{...}`) to merge new values into existing objects instead of using nested objects.
2. **Functional programming libraries**: Libraries like Ramda or Immutable.js provide functional programming abstractions that can be used for object manipulation and updates.
3. **Custom implementation**: Depending on your specific requirements, you could implement a custom algorithm for updating values in objects, potentially leveraging native browser APIs or low-level JavaScript features.

Keep in mind that the performance differences between these approaches may vary depending on the specific use case, object size, and other factors.

Related benchmarks:

Lodash set vs multiple destructuring (version: 0)

Comparing performance of: Lodash set vs Native destructuring

Created: 5 years ago by: Guest

Jump to the latest result

Lodash set

Native destructuring

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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