Benchmark: lodash vs ramda vs manual

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js'></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>

Script Preparation code:

var MyObject = {
  description: 'Creates a deep copy of source, which should be an object or an array.',
  myNumber: 123456789,
  myBoolean: true,
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  }
};

var myCopy = null;

Tests:

lodash
myCopy = _.cloneDeep(MyObject);
ramda
myCopy = R.clone(MyObject);
manual
myCopy = { ...MyObject, jayson: { ...MyObject.jayson } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
ramda
manual

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Overview**

The benchmark is comparing the performance of three approaches to create a deep copy of an object: Lodash, Ramda, and a manual implementation.

**Test Cases**

Each test case is defined by a `Benchmark Definition` string that specifies how to create a deep copy of the input object `MyObject`. There are three test cases:

1. **Lodash**: `myCopy = _.cloneDeep(MyObject);`
	* Lodash is a popular JavaScript library for functional programming utilities.
	* The `.cloneDeep()` method creates a deep clone of an object, which means it recursively copies all properties and values from the original object.
2. **Ramda**: `myCopy = R.clone(MyObject);`
	* Ramda is another popular JavaScript library for functional programming utilities.
	* The `R.clone()` function also creates a deep clone of an object, similar to Lodash's `.cloneDeep()`.
3. **Manual**: `myCopy = {\r\n\t...MyObject,\r\n  \tjayson: { ...MyObject.jayson }\r\n}`
	* This is the manual implementation of creating a deep copy of an object.
	* The manual approach uses the spread operator (`...`) to create a new object with all properties from `MyObject`, and then updates the `jayson` property by creating a new object with only the necessary properties.

**Library and Purpose**

Both Lodash and Ramda are popular JavaScript libraries that provide functional programming utilities, including methods for working with objects, arrays, and functions. They aim to make code more concise and expressive, while also providing performance benefits.

In this benchmark, both libraries use their respective `.cloneDeep()` or `R.clone()` methods to create a deep copy of the input object `MyObject`.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. The code uses standard JavaScript features, such as objects, arrays, and functions.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **Lodash**:
	* Pros: Easy to use, well-maintained library with many built-in utilities.
	* Cons: Additional dependency, may be overkill for simple cloning tasks.
2. **Ramda**:
	* Pros: Similar to Lodash, but with a different API that some developers prefer.
	* Cons: Additional dependency, similar pros and cons as Lodash.
3. **Manual**:
	* Pros: No additional dependencies, highly optimized code for small cloning tasks.
	* Cons: More verbose code, requires manual implementation of deep copying logic.

**Other Alternatives**

If you don't want to use a library or prefer not to add an extra dependency, there are alternative approaches:

1. **Using `JSON.parse(JSON.stringify())`**: This method creates a shallow copy of an object by converting it to a JSON string and then parsing the resulting string back into an object.
2. **Using `Array.prototype.slice()` and `Object.assign()`**: For objects with only enumerable properties, you can create a deep copy using `Array.prototype.slice()` and `Object.assign()`. However, this approach may not work correctly for objects with non-enumerable properties or symbols.

These alternatives are generally less performant than the manual implementation or library-based approaches.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Windows

View result in a separate tab

Test name	Executions per second
lodash	500997.0 Ops/sec
ramda	681044.2 Ops/sec
manual	3053517.0 Ops/sec

Related benchmarks:

lodash vs ramda vs manual (version: 0)

Comparing performance of: lodash vs ramda vs manual

Created: 4 years ago by: Guest

Jump to the latest result

lodash

ramda

manual

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