Benchmark: Array Lodash cloneDeep vs JSON Clone

HTML Preparation code:

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

Script Preparation code:

var item1 = {
  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 item2 = {
  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 items = [item1, item2];

var myCopy = null;

Tests:

Lodash cloneDeep
myCopy = items.map(item=>_.cloneDeep(item));
Json clone
myCopy = JSON.parse(JSON.stringify(items));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone

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 world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmark test created on MeasureThat.net, which compares the performance of two approaches for cloning (or copying) an array in JavaScript:

1. Using Lodash's `cloneDeep` function
2. Using the built-in `JSON.parse(JSON.stringify())` method

**What is being tested?**

The test creates two objects (`item1` and `item2`) with nested properties, including a JSON object (`jayson`). It then creates an array of these objects (`items`). The benchmark measures how quickly each approach can create a deep copy of the entire `items` array.

**Options compared**

Two options are being compared:

1. **Lodash's `cloneDeep` function**: This is a popular library that provides a way to create deep copies of objects and arrays.
2. **Built-in `JSON.parse(JSON.stringify())` method**: This method converts JavaScript values to JSON strings and back, which can be used to create a copy of an object.

**Pros and Cons**

**Lodash's `cloneDeep` function:**

Pros:

* Provides a robust way to create deep copies of complex objects
* Handles circular references (where an object refers to itself)
* Can handle various data types, including arrays

Cons:

* Requires an external library (Lodash) to be included in the test environment
* May have performance overhead due to the need to include an additional script

**Built-in `JSON.parse(JSON.stringify())` method:**

Pros:

* Does not require any additional libraries or scripts
* Fast and lightweight implementation

Cons:

* Only works for simple, non-circular objects
* Does not handle complex data types (e.g., arrays) well

**Other considerations**

When choosing between these two approaches, consider the specific requirements of your use case. If you need to work with complex, nested objects or arrays, Lodash's `cloneDeep` function may be a better choice. However, if you're working with simple, non-circular data and want the fastest possible performance, the built-in `JSON.parse(JSON.stringify())` method might be sufficient.

**Library: JSON**

The `JSON` library is not explicitly mentioned in the provided code, but it's implied as part of the implementation of the `JSON.parse(JSON.stringify())` method. The `JSON` library provides functions for converting JavaScript values to and from JSON strings, which is used by the built-in `JSON.parse(JSON.stringify())` method.

**Special JS feature/syntax:**

The benchmark uses a common JavaScript feature called "arrow functions" (e.g., `item=>_.cloneDeep(item)`). Arrow functions are a shorthand way of defining functions that use the `=>` operator instead of `function()`. They're commonly used in modern JavaScript code, but may not be supported by older browsers or environments.

I hope this explanation helps you understand what's being tested in this benchmark!

Related benchmarks:

Array Lodash cloneDeep vs JSON Clone (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

Created: 4 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

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