Benchmark: fp.assign vs fp.set vs spread vs mutable

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script>

Tests:

fp.assign
const state = { a: '1', b: '2', c: { ca: 1 } }; const report = { c: { cb: 2, }, d: '4', } const newState = _.assign(state, report);
fp.set
const state = { a: '1', b: '2', c: { ca: 1 } }; const report = { c: { cb: 2, }, d: '4', } const newState = _.flow( _.set('c', report.c), _.set('d', report.d), )(state);
spread
const state = { a: '1', b: '2', c: { ca: 1 } }; const report = { c: { cb: 2, }, d: '4', } const newState = { ...state, ...report };
mutable
const state = { a: '1', b: '2', c: { ca: 1 } }; const report = { c: { cb: 2, }, d: '4', } state.c.cb = 2; state.d = '4';

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
fp.assign
fp.set
spread
mutable

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
fp.assign	3119840.8 Ops/sec
fp.set	351029.6 Ops/sec
spread	5229830.5 Ops/sec
mutable	942305600.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Overview**

The provided JSON represents a set of JavaScript microbenchmarks hosted on MeasureThat.net. The goal is to compare the performance of different approaches to assign or update values in an object. There are four test cases: `fp.assign`, `fp.set`, `spread`, and `mutable`.

**Options Compared**

1. **FP (Functional Programming) Assign**: This approach uses a functional programming style to create a new object with updated values, without modifying the original object.
2. **FP Set**: Similar to FP Assign, but uses the `_._set()` method provided by Lodash's fp module to update specific properties of an object.
3. **Spread**: This approach uses the spread operator (`{ ... }`) to create a new object with updated values, merging the original object with a new object containing the updates.
4. **Mutable**: This approach modifies the original object directly by assigning values to its properties.

**Pros and Cons**

1. **FP Assign and FP Set**: These approaches provide a functional programming style that is often preferred for its predictability, composability, and immutability. However, they may be slower than other approaches because of the overhead of creating new objects.
2. **Spread**: This approach is generally fast because it only creates a shallow copy of the object, which can be optimized by JavaScript's garbage collector. However, it may not work correctly with nested objects or complex data structures.
3. **Mutable**: Modifying the original object directly can be faster than creating new objects, but it also means that changes made to the object will affect all other parts of the codebase that use the same object.

**Lodash Library**

The Lodash library is used in the FP Set test case. Lodash provides a set of functional programming utilities, including the `fp` module, which provides functions for working with immutable data structures and objects. The `_._set()` method is used to update specific properties of an object without modifying the original object.

**Special JS Feature**

There is no special JavaScript feature or syntax that requires explanation in this benchmark.

**Other Alternatives**

In addition to these four approaches, there are other ways to assign or update values in an object, such as:

* Using the `Object.assign()` method
* Using a library like Immutable.js for immutable data structures
* Using a framework like React, which provides its own way of managing state and props.

It's worth noting that the choice of approach will depend on the specific use case and requirements of the application.

Related benchmarks:

fp.assign vs fp.set vs spread vs mutable (version: 0)

Comparing performance of: fp.assign vs fp.set vs spread vs mutable

Created: one year ago by: Guest

Jump to the latest result

fp.assign

fp.set

spread

mutable

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