Js Does Object Assign Create Deep Copy Or Shallow Copy

When working with JavaScript, understanding key concepts like object assignment and copying is crucial for writing efficient and bug-free code. One common question that often arises is whether the `Object.assign()` method creates a deep copy or a shallow copy. Let's dive into this topic to clarify any confusion you may have.

First off, let's differentiate between deep and shallow copies. A shallow copy simply creates a new object and copies the top-level properties of the original object. In contrast, a deep copy not only replicates the top-level properties but also recursively copies all nested objects and their properties, ensuring that the copied object is entirely independent of the original.

So, what about `Object.assign()` in JavaScript? Well, the `Object.assign()` method is used to copy the values of all enumerable and own properties from one or more source objects to a target object. However, it only performs a shallow copy. This means that while the top-level properties are copied to the target object, any nested objects within the source object are still referenced in the target object. Changes made to nested objects in the target object will affect the original object.

If you need to create a deep copy of an object in JavaScript, the `Object.assign()` method alone won't suffice. One way to achieve a deep copy is by combining `Object.assign()` with some additional techniques such as using `JSON.parse()` and `JSON.stringify()`.

Here is an example of how you can create a deep copy of an object in JavaScript:

function deepCopy(obj) {
  return JSON.parse(JSON.stringify(obj));
}

const originalObject = {
  a: 1,
  b: {
    c: 2,
  },
};

const deepCopiedObject = deepCopy(originalObject);

originalObject.b.c = 5;

console.log(deepCopiedObject.b.c); // Output: 2

In this example, the `deepCopy()` function takes an object as an argument, converts it to a JSON string using `JSON.stringify()`, and then parses the JSON string back to an object using `JSON.parse()`. This process effectively creates a new object that is a deep copy of the original object, including all nested objects and their properties.

By understanding the distinction between deep and shallow copies and knowing how to create a deep copy when needed, you can ensure that your JavaScript code behaves as expected and avoids unexpected side effects due to object referencing.

In conclusion, while `Object.assign()` in JavaScript is useful for making shallow copies of objects, for deep copies, you'll need to employ additional techniques such as `JSON.parse()` and `JSON.stringify()`. Mastering these concepts will empower you to write more robust and reliable code in your JavaScript projects.