Benchmark: compare clone way

Tests:

json stringify
var obj = {a: "hello", c: "test", po: 33, arr: [1, 2, 3, 4], anotherObj: {a: 33, str: "whazzup"}}; var obj2 = JSON.parse(JSON.stringify(obj));
lodash deep clone
var obj = {a: "hello", c: "test", po: 33, arr: [1, 2, 3, 4], anotherObj: {a: 33, str: "whazzup"}}; var obj2 = _.clone(obj, true);
Object.assign
var obj = {a: "hello", c: "test", po: 33, arr: [1, 2, 3, 4], anotherObj: {a: 33, str: "whazzup"}}; var obj2 = Object.assign({}, obj);
Spread Operator
var obj = {a: "hello", c: "test", po: 33, arr: [1, 2, 3, 4], anotherObj: {a: 33, str: "whazzup"}}; var obj2 = {...obj};

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
json stringify
lodash deep clone
Object.assign
Spread Operator

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark is designed to compare four different approaches for creating a shallow copy of an object in JavaScript:

1.  **JSON.stringify() + JSON.parse()**: This approach uses the `JSON.stringify()` method to serialize the original object, and then parses the resulting string back into an object using `JSON.parse()`.
2.  **Lodash deep clone (`_clone()`)**: This approach utilizes the `_.clone()` function from the Lodash library to create a deep copy of the original object.
3.  **Object.assign()**: This approach uses the `Object.assign()` method to create a new object with the same properties as the original object, without modifying it.
4.  **Spread Operator (`{...obj}`)**: This approach utilizes the spread operator (also known as the rest operator) to create a new object by copying the properties of the original object.

**Pros and Cons of Each Approach:**

*   **JSON.stringify() + JSON.parse()**: This approach is simple to implement but can be slower due to the overhead of serializing and parsing the object. It also requires careful handling of circular references, as `JSON.parse()` will throw an error if it encounters a circular reference.
*   **Lodash deep clone (`_clone()`)**: This approach provides a robust way to create a deep copy of objects, but it comes with the added cost of including Lodash in your project. It's generally faster than using `JSON.stringify()` + `JSON.parse()`.
*   **Object.assign()**: This approach is simple and efficient, as it only requires a single method call. However, it can be slower for large objects due to the overhead of creating a new object.
*  **Spread Operator (`{...obj}`)**: This approach is concise and expressive but may not work as expected if the original object contains functions or other special values.

**Other Considerations:**

*   The use of Lodash in this benchmark highlights its importance for creating efficient and robust deep copies of objects.
*   The choice of browser (Chrome 84) and device platform (Desktop, Windows) affects the performance results, as different browsers and platforms may have varying speeds and memory layouts.

**Alternatives:**

If you're looking for alternative approaches to create shallow or deep copies of objects in JavaScript:

*   **Shallow Copy:** You can use the spread operator (`{...obj}`) without `Object.assign()`.
*   **Deep Copy with Lodash:** Consider using the `_cloneDeep()` function from Lodash, which provides a more robust way to create deep copies of complex objects.

In conclusion, each approach has its strengths and weaknesses, and the choice of method depends on your specific use case, performance requirements, and personal preference. MeasureThat.net's benchmark helps you understand the relative performance of these methods in a controlled environment.

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/84.0.4147.125 Safari/537.36

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
json stringify	427443.1 Ops/sec
lodash deep clone	1338536.4 Ops/sec
Object.assign	4112134.0 Ops/sec
Spread Operator	51483660.0 Ops/sec

Related benchmarks:

compare clone way (version: 0)

Comparing performance of: json stringify vs lodash deep clone vs Object.assign vs Spread Operator

Created: 4 years ago by: Guest

Jump to the latest result

json stringify

lodash deep clone

Object.assign

Spread Operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):