Shallow Copy VS Deep Copy

In JavaScript, the concepts of shallow copy and deep copy are related to the duplication of objects, arrays, or other complex data structures. Understanding the difference between these two types of copies is crucial for managing data effectively and preventing unintended side effects in your code.

Shallow Copy:

• A shallow copy creates a new object or array and copies the elements of the original one to the new one. However, it does not create copies of nested objects or arrays; instead, it copies references to them.
• Shallow copying is performed using methods like Object.assign(), the spread operator (...), or array methods like slice() or concat().
• Shallow copies are faster and consume less memory since they only copy references. However, they may lead to unexpected behavior if the original and copied objects share references to nested objects.

// original object
const originalObject = {
  name: "Alice",
  age: 25,
  address: {
    city: "Wonderland",
    country: "JavaScript"
  }
};

// Shallow copy
const shallowCopy = { ...originalObject };

// Let's change a nested property
shallowCopy.address.city = "Mirrorland";

console.log(originalObject.address.city); // Outputs: Mirrorland

Deep Copy:

• A deep copy, on the other hand, creates a completely independent copy of the original object or array, including all nested objects and arrays.
• Achieving a deep copy can be more complex and usually requires custom implementation, such as using recursion to traverse the entire structure and create new instances for each nested element.
• Deep copies provide true isolation between the original and copied data, ensuring that changes to one do not affect the other. However, they can be slower and consume more memory, especially for large and complex data structures.

// Deep copy using a utility function
function deepCopy(obj) {
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }

  const newObj = Array.isArray(obj) ? [] : {};

  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      newObj[key] = deepCopy(obj[key]);
    }
  }

  return newObj;
}

// original object
const originalObject = {
  name: "Alice",
  age: 25,
  address: {
    city: "Wonderland",
    country: "JavaScript"
  }
};

// Deep copy
const copyObject = deepCopy(originalObject);

// Let's change a nested property
copyObject.address.city = "Mirrorland";

console.log(originalObject.address.city); // Outputs: Wonderland

Pros and Cons

Shallow Copy

Pros: Lightweight, maintains references, suitable for simple structures.
Cons: Changes to nested structures affect both original and copy, may lead to unexpected behavior."

Deep Copy

Pros: Independent duplicates, changes do not affect the original, suitable for complex structures.
Cons: May be computationally expensive, potential issues with circular references."

Best Practices

• Use shallow copy when dealing with simple structures and you want to maintain lightweight references.
• Opt for deep copy when working with complex structures or when you need completely independent duplicates.

Conclusion

In the enchanting world of JavaScript, cloning objects goes beyond the basics of duplication. Shallow copy and deep copy are two sides of the same mirror, each with its own strengths and weaknesses. The choice between them depends on the specific needs of your application.

So, as you venture into the mystical realms of JavaScript development, remember that a mirror is not just a reflection; it's a portal to the depths of your data. Embrace the art of cloning, and may your mirrors be as magical as Alice's in the Wonderland of JavaScript.

Happy coding!