Benchmark: Lodash Set performance

HTML Preparation code:

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

Script Preparation code:

var obj = {
    a: {
        b: [ { c: 'Before' } ]
    }
};

function setValue(obj, path, value) {
  var a = path.split('.')
  var o = obj
  while (a.length - 1) {
    var n = a.shift()
    if (!(n in o)) o[n] = {}
    o = o[n]
  }
  o[a[0]] = value
}

/*your preparation JavaScript code goes here
To execute async code during the script preparation, wrap it as function globalMeasureThatScriptPrepareFunction, example:*/
async function globalMeasureThatScriptPrepareFunction() {
    // This function is optional, feel free to remove it.
    // await someThing();
}

Tests:

Lodash
_.set(obj, "a.b.0.c", "After");
Simple
setValue(obj, "a.b.0.c", "After");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Simple

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 days ago)

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	2958853.5 Ops/sec
Simple	5530815.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 10 days ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview: Lodash Set Performance

This benchmark compares the performance of two different methods for setting a value in a deeply nested JavaScript object: using the Lodash library and a custom simple implementation. The key focus of this benchmark is to evaluate how each method performs in terms of execution speed.

### Implementations Compared

1. **Lodash Implementation**: 
   - **Code**: `_.set(obj, "a.b.0.c", "After");`
   - **Library**: Lodash
   - **Purpose**: Lodash is a widely-used JavaScript utility library that provides modular functions for common programming tasks, such as manipulating arrays, objects, and strings. The `_.set` function is specifically designed to update the value at a specific path of an object safely, handling the creation of nested structures if they do not already exist.

2. **Simple Implementation**: 
   - **Code**: `setValue(obj, "a.b.0.c", "After");`
   - **Custom Function**: `setValue`
   - **Purpose**: The `setValue` function is a custom implementation that manually splits the string path, iterates through the object, and assigns the value at the designated path. If the path does not exist, it dynamically creates the necessary nested structure.

### Performance Results

The benchmark results provided show the executions per second for each method:
- **Simple Implementation**: 5,530,815 executions per second
- **Lodash Implementation**: 2,958,853.5 executions per second

### Pros and Cons of Approaches

1. **Lodash Approach**:
   - **Pros**:
     - **Abstraction**: Simplifies the usage of setting values in complex objects, making code more readable.
     - **Robustness**: Handles edge cases (e.g., trying to set a value on a path that doesn't exist) more gracefully. It is generally more forgiving with errors in object structure.
     - **Community Support**: As a popular utility library, it comes with extensive documentation and community support.
   - **Cons**:
     - **Performance**: In this benchmark, it was significantly slower than the simple implementation, which could be a concern in performance-critical applications.
     - **Overhead**: Introduces additional overhead of including a large library in projects, which may not always be necessary for small tasks.

2. **Simple Implementation**:
   - **Pros**:
     - **Performance**: Faster in execution as shown in the benchmark results, providing a more optimized approach for setting nested values.
     - **Lightweight**: No external dependencies are required, making the codebase cleaner and potentially reducing load times.
   - **Cons**:
     - **Complexity**: Requires more code to handle edge cases and may lead to increased potential for bugs if not written cautiously.
     - **Readability**: Can be less intuitive for those unfamiliar with how the function operates, leading to harder maintenance.

### Additional Considerations

- **Use Cases**: If performance is the primary concern—especially in performance-critical applications where many updates to deeply nested structures are performed—the simple implementation may be preferred. However, if you're working in an environment needing clean and maintainable code with some level of abstraction, Lodash might be more suitable.
  
- **Alternatives**: Other libraries for deep object manipulations include:
  - **Immutable.js**: Focused on immutable data structures but can add complexity.
  - **Ramda**: Functional programming approach but may come with a steeper learning curve.
  - **Native JavaScript**: Newer JavaScript features such as optional chaining and nullish coalescing can simplify accessing nested properties without a library, but not specifically for setting values.

This benchmark ultimately highlights a trade-off between raw performance and the convenience of using a comprehensive utility library like Lodash. The choice between the two methods will depend on the specific needs of the project, available resources, and team expertise.

Related benchmarks:

Lodash Set performance (version: 1)

perf check vs simple implementation

Comparing performance of: Lodash vs Simple

Created: 10 days ago by: Guest

Jump to the latest result

Lodash

Simple

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 10 days ago):