Benchmark: Clone objects - MeasureThat.net

Script Preparation code:

var obj = {};
var objCount = 100;

for (let i = 0; i < objCount; i++) {
    obj[i] = [1, 2, 3];
}

function deepClone(objIn) {
    let copy;

    if (objIn === null || typeof objIn !== 'object') {
        return obj;
    }

    if (objIn instanceof Array) {
        copy = [];
        for (let i = 0, len = objIn.length; i < len; i++) {
            copy[i] = deepClone(objIn[i]);
        }
        return copy;
    }

    if (objIn instanceof Object) {
        copy = {};
        for (const attr in objIn) {
            if (objIn.hasOwnProperty(attr)) {
                copy[attr] = deepClone(objIn[attr]);
            }
        }
        return copy;
    }

}

function deepMerge(target, ...sources) {
 if (!sources.length) return target
 const source = sources.shift()

 if (isObject(target) && isObject(source)) {
  for (const key in source) {
   if (isObject(source[key])) {
    if (!target[key]) Object.assign(target, {[key]: {}})
    deepMerge(target[key], source[key])
   } else {
    Object.assign(target, {[key]: source[key]})
   }
  }
 }

 return deepMerge(target, ...sources)
}

function isObject(obj) {
 return obj && typeof obj === "object" && !Array.isArray(obj) 
}

Tests:

DeepClone
var clone = deepClone(obj);
JSON.stringify
var clone = JSON.parse(JSON.stringify(obj));
deepMerge
var clone = deepMerge({}, obj)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
DeepClone
JSON.stringify
deepMerge

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
DeepClone	215411.1 Ops/sec
JSON.stringify	112040.7 Ops/sec
deepMerge	35537.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON focuses on the performance of different methods for cloning objects in JavaScript. There are three main approaches tested: using a custom deep cloning function (`deepClone`), using `JSON.stringify` and `JSON.parse`, and using a custom deep merging function (`deepMerge`). Each of these methods has its pros and cons, and their performance is evaluated in terms of how many executions can be completed per second.

### Approaches Compared

1. **Deep Clone (`deepClone`)**
   - **Implementation**: This function recursively constructs a new object (or array) by copying properties from the input object. If it encounters nested objects or arrays, it continues to clone those recursively.
   - **Performance**: Given the results, this method outperformed the others with **215,411 executions per second**.
   - **Pros**:
     - Handles complex structures and circular references (with additional logic to deal with them if implemented).
     - Can be customized easily for specific needs.
   - **Cons**:
     - Recursive nature can lead to stack overflow errors with very deep structures.
     - The implementation can be slower for simple cases compared to native alternatives when optimized.

2. **JSON.stringify / JSON.parse**
   - **Implementation**: This method converts the object to a JSON string and then parses it back into a new object. It works well for serializable structures but fails on functions, `undefined`, and handles dates as strings.
   - **Performance**: This approach had an execution rate of **112,040** executions per second.
   - **Pros**:
     - Simple and concise to use.
     - Handles basic object cloning efficiently.
   - **Cons**:
     - Loses data on non-serializable properties (e.g., functions, `undefined`, and symbols).
     - Does not clone prototypes or instance methods.

3. **Deep Merge (`deepMerge`)**
   - **Implementation**: This function merges properties from multiple source objects into a target object recursively. It's designed to handle nested objects.
   - **Performance**: This method had the slowest execution, with **35,537** executions per second.
   - **Pros**:
     - Useful for merging configurations or combining multiple data sources.
     - Can be valuable when configuring settings that need to preserve initial values.
   - **Cons**:
     - Not primarily for cloning but merging, which makes it awkward for use cases specifically intended for cloning.
     - Can introduce complexity when types clash or when merging objects with circular references.

### Considerations
- **Use Case Applicability**: Choosing a method depends on the specific use case. If creating a clone of an object with potential for functions or deep structures, `deepClone` is preferable. For basic structure cloning without functions or undefined values, `JSON.stringify` provides an efficient solution. If merging objects, `deepMerge` is suitable but is not meant for deep cloning.
- **Performance Evaluation**: When performance is critical (e.g., cloning objects aggressively in a loop or processing large datasets), the most efficient approach should be selected based on the nature of the objects being handled.
- **Data Integrity**: Developers must consider the need for data integrity, particularly regarding properties that may not serialize correctly or that may be important to maintain intact.

### Alternatives
- **Structured Clone**: In modern browsers, the `structuredClone()` function serves as a native option to handle deep cloning with support for a broader range of data types compared to `JSON.stringify`.
- **Lodash Library**: The `_.cloneDeep()` function from the Lodash library provides a reliable and optimized solution for deep cloning, maintaining better performance on various object structures than a simple manual implementation.
- **Shallow Cloning Methods**: For shallow copies, using object spread (`{...obj}`) or `Object.assign()` is efficient for flat structures but may not serve deep cloning needs.

Overall, the benchmark results give insight into performance differences among cloning strategies, critical for software engineers to choose the right method based on their application's needs and the complexity of the objects involved.

Related benchmarks:

Clone objects (version: 1)

Comparing performance of: DeepClone vs JSON.stringify vs deepMerge

Created: one month ago by: Registered User

Jump to the latest result

DeepClone

JSON.stringify

deepMerge

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):