Table of contents
1.
Introduction
2.
Why This Function is Used
3.
Syntax, Parameter and Return Value
3.1.
Syntax:
3.2.
Parameters:
3.3.
Return Value: 
4.
Examples 
4.1.
Deep Cloning an Object with Nested Structures:
4.2.
JavaScript
4.3.
Deep Cloning Arrays Containing Objects:
4.4.
JavaScript
4.5.
Preserving Complex Data Structures:
4.6.
JavaScript
4.7.
Cloning Objects with Methods:
4.8.
JavaScript
5.
Frequently Asked Questions
5.1.
How does deep cloning differ from shallow cloning?
5.2.
Does _.cloneDeep() handle all types of data?
5.3.
Can _.cloneDeep() lead to performance issues?
6.
Conclusion
Last Updated: Mar 27, 2024
Easy

Lodash _.cloneDeep() Method

Author Gaurav Gandhi
0 upvote
Career growth poll
Do you think IIT Guwahati certified course can help you in your career?

Introduction

In JavaScript, cloning complex objects and arrays often requires more than just a shallow copy, especially when dealing with nested structures. Lodash's _.cloneDeep() method addresses this need by providing a way to create deep copies of values. 

Lodash _.cloneDeep() Method

This function recursively clones every level of the object or array, ensuring that no references to the original data remain. It is particularly useful for duplicating intricate data structures without altering the original source.

Why This Function is Used

The _.cloneDeep() function is used to make a complete copy of complex objects or arrays, including all nested elements. This is essential when you need to work with a replica of an object or array without affecting the original, especially in scenarios involving nested data structures, configurations, or state management. Deep cloning ensures that changes made to the clone do not impact the original data, preserving data integrity.

Syntax, Parameter and Return Value

Syntax:

 _.cloneDeep(value)

Parameters:

value (Object|Array): The value to deeply clone.

Return Value: 

Returns the deeply cloned value.

Examples 

Deep Cloning an Object with Nested Structures:

  • JavaScript

JavaScript

var _ = require('lodash');

var object = { a: 1, b: { c: 2, d: [3, 4] } };

var clonedObject = _.cloneDeep(object);

clonedObject.b.c = 5;

clonedObject.b.d.push(6);

console.log(object);

console.log(clonedObject);
You can also try this code with Online Javascript Compiler
Run Code

Output: 

{ a: 1, b: { c: 2, d: [3, 4] } }
{ a: 1, b: { c: 5, d: [3, 4, 6] } }


Demonstrates cloning an object with nested arrays and objects. Changes to the clone do not affect the original.

Deep Cloning Arrays Containing Objects:

  • JavaScript

JavaScript

var items = [{ id: 1, name: 'Item 1' }, { id: 2, name: 'Item 2' }];

var clonedItems = _.cloneDeep(items);

clonedItems[0].name = 'Updated Item 1';

console.log(items);      

console.log(clonedItems);
You can also try this code with Online Javascript Compiler
Run Code

 Output:

[{ id: 1, name: 'Item 1' }, { id: 2, name: 'Item 2' }]
[{ id: 1, name: 'Updated Item 1' }, { id: 2, name: 'Item 2' }]


Shows how to deep clone an array containing objects, allowing for independent modifications.

Preserving Complex Data Structures:

  • JavaScript

JavaScript

var complexStructure = {

 date: new Date(),

 nested: { numbers: [1, 2, 3], flag: true }

};

var clone = _.cloneDeep(complexStructure);

clone.nested.numbers.push(4);

console.log(complexStructure.nested.numbers);

console.log(clone.nested.numbers);         
You can also try this code with Online Javascript Compiler
Run Code

   

Output: 

[1, 2, 3]
[1, 2, 3, 4]


An example of deep cloning a complex structure with dates and nested objects.

Cloning Objects with Methods:

  • JavaScript

JavaScript

var person = {

 name: 'Alice',

 greet: function() { console.log('Hello, ' + this.name); }

};

var clonedPerson = _.cloneDeep(person);

clonedPerson.name = 'Bob';

clonedPerson.greet();

person.greet();     
You can also try this code with Online Javascript Compiler
Run Code

 Output: 

 'Hello, Bob'
'Hello, Alice'


Demonstrates that methods within objects are also cloned, and the cloned methods reference the cloned data.

Frequently Asked Questions

How does deep cloning differ from shallow cloning?

Deep cloning creates copies of all items within an object or array, including nested structures, ensuring no references to the original data. Shallow cloning only copies the top-level elements.

Does _.cloneDeep() handle all types of data?

_.cloneDeep() effectively clones most data types, including arrays, objects, and primitives. However, it may not handle some special objects (like functions, Map, Set, or circular references) as expected.

Can _.cloneDeep() lead to performance issues?

Deep cloning can be resource-intensive, especially for very large or complex objects. It's important to use it judiciously to avoid performance overhead.

Conclusion

Lodash's _.cloneDeep() method is essential for creating independent copies of complex data structures. It allows for safe modification of cloned data without any impact on the original source, making it invaluable in various programming scenarios.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSADBMSCompetitive ProgrammingPythonJavaJavaScript, etc. 

Also, check out some of the Guided Paths on topics such as Data Structure and AlgorithmsCompetitive ProgrammingOperating SystemsComputer Networks, DBMSSystem Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.

Live masterclass