What are the methods to implement deep copy in JS?

What are the methods to implement deep copy in JS, specific code examples are required

In JavaScript, copying is a common operation. Sometimes we need to copy an object, but just using a simple assignment operator (=) is not enough, because it just copies the reference to a new variable instead of creating a new object.

Therefore, in order to implement deep copy, we need to consider how to copy all properties of the object and nested objects. Next, I will introduce two commonly used methods to implement deep copy and give specific code examples.

Method 1: Use JSON.parse and JSON.stringify methods

JSON.parse and JSON.stringify are two methods for processing JSON format in JavaScript. They can help us implement deep copy. The specific steps are as follows:

1. Use JSON.stringify to convert the source object into a JSON string;
2. Use JSON.parse to convert the JSON string into a new object.

The specific code is as follows:

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

The advantage of this method is that it is simple and easy to understand and is suitable for objects in most situations. However, this method has some limitations. First, it cannot handle special objects such as functions, regular expressions, and date objects. Secondly, if the source object contains a circular reference (that is, there are mutual references within the object), this method will throw an exception.

Method 2: Recursive copy

Recursive copy is another commonly used deep copy method. It implements a deep copy by iterating through the properties of the source object and recursively copying the nested objects. The specific steps are as follows:

1. Create a new target object;

2. Traverse the properties of the source object and determine whether the property is an object type;

   • If the attribute is an object type, call the deepClone function recursively to perform a deep copy;
   • If the attribute is not an object type, copy it directly to the target object;
3. Return to the target object.

The specific code is as follows:

function deepClone(obj) {
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }
  
  let clone = Array.isArray(obj) ? [] : {};
  
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clone[key] = deepClone(obj[key]);
    }
  }
  
  return clone;
}

Using the recursive copy method can handle more complex objects, including functions, regular expressions, date objects, etc. It also correctly handles circular reference situations because a new copy is created for each object.

It should be noted that the recursive copy method may have some performance problems, especially when the object is very large or complex. In this case, you can consider using other efficient libraries or methods, such as lodash's cloneDeep method.

Summary:

This article introduces two commonly used JS methods to implement deep copy, and provides specific code examples. Choosing the appropriate method depends on your needs and the characteristics of your object. It should be noted that in some special cases, such as circular references, special handling may be required.

No matter which method you choose, deep copying is a very important operation. It can help us create independent copies of objects and avoid the side effects caused by reference transfer. During the development process, when objects need to be modified or compared, we should choose an appropriate deep copy method to ensure the correctness and stability of the code.

The above is the detailed content of What are the methods to implement deep copy in JS?. For more information, please follow other related articles on the PHP Chinese website!