Benchmark: Immer/Ramda - MeasureThat.net

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/immer/dist/immer.umd.js"></script>

Script Preparation code:

window.foo = { 
  a: Array(100).fill(), 
  b: Array(100).fill(), 
  c: { 
    e: {
      g: Array(100).fill(),
      h: {
        i: false,
        j: Array(100).fill()
      }
    }, 
    f: Array(100).fill()
  }, 
  d: 1 
}

Tests:

JS
const newFoo = { ...foo, c: { ...foo.c, e: { ...foo.c.e, h: { ...foo.c.e.h, i: true } } } }
Ramda
const newFoo = R.mergeDeepRight(foo, { c: { e: { h: { i: true }}}})
Immer
const newFoo = immer.produce(foo, (draft) => { draft.c.e.h.i = true })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JS
Ramda
Immer

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

User agent: Mozilla/5.0 (Linux; Android 8.1.0; Aquaris X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.127 Mobile Safari/537.36 OPR/60.2.3004.55409

Browser/OS: Opera Mobile 60 on Android 8.1.0

View result in a separate tab

Test name	Executions per second
JS	225995.5 Ops/sec
Ramda	95684.7 Ops/sec
Immer	14604.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is an essential task for developers who need to optimize their applications' execution speed. The provided benchmark, MeasureThat.net, offers a great platform for comparing different approaches.

**Overview of the Benchmark**

The benchmark tests three approaches: JavaScript (JS), Ramda, and Immer. Each approach has its own set of test cases, which are used to measure the performance of each method.

**What is being tested?**

The benchmark tests the following:

*   **JavaScript**: The original JavaScript code that uses the spread operator (`...`) to create a new object with the desired properties.
*     **Ramda**: A functional programming library that provides a `mergeDeepRight` function, which is used to merge two objects and overwrite the target object's properties with the values from the source object.
*   **Immer**: A state management library that provides an `immer.produce` function, which is used to create a new draft of an object by modifying the original object.

**Options being compared**

The benchmark compares three options:

1.  **JavaScript (JS)**: Uses the spread operator (`...`) to create a new object with the desired properties.
2.  **Ramda**: Uses the `mergeDeepRight` function from Ramda to merge two objects and overwrite the target object's properties with the values from the source object.
3.  **Immer**: Uses the `immer.produce` function from Immer to create a new draft of an object by modifying the original object.

**Pros and Cons**

Here are some pros and cons for each approach:

*   **JavaScript (JS)**:
    *   Pros: Easy to understand, flexible, and widely supported.
    *   Cons: May be slower than Ramda or Immer due to its dynamic nature.
*   **Ramda**: 
    *   Pros: Provides a standardized and predictable way of merging objects. Efficient performance due to immutable data structures.
    *   Cons: Requires the use of an external library (Ramda), which may not be desirable in all cases.
*   **Immer**:
    *   Pros: Offers a lightweight and efficient state management solution, especially for small objects.
    *   Cons: May have performance overhead due to the creation of new drafts.

**Library Overview**

The benchmark uses two external libraries:

1.  **Ramda**: A functional programming library that provides various utility functions, including `mergeDeepRight`.
2.  **Immer**: A state management library that provides an `immer.produce` function for creating new drafts of objects.

**Special JS Features/Syntax**

*   The benchmark uses the spread operator (`...`) to create a new object with the desired properties in the JavaScript test case.
*   Ramda's `mergeDeepRight` function is used to merge two objects and overwrite the target object's properties with the values from the source object.

**Alternatives**

If you don't want to use external libraries, you can also consider the following alternatives:

1.  **Lodash**: A utility library that provides various functions for manipulating objects, including `merge`.
2.  **ES6 Object Merging**: You can achieve object merging using ES6's rest operator (`{...obj, ...rest}`) or the spread operator (`{...a, ...b}`).
3.  **Manual Implementation**: You can implement your own function for merging objects using a loop or recursive approach.

In summary, MeasureThat.net provides a comprehensive benchmarking platform that allows developers to compare different approaches for JavaScript object merging. By understanding the pros and cons of each option, you can choose the best method for your specific use case.

Related benchmarks:

Immer/Ramda (version: 0)

Comparing performance of: JS vs Ramda vs Immer

Created: 4 years ago by: Guest

Jump to the latest result

JS

Ramda

Immer

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