编程语言中浅拷贝（Shallow Copy）和深拷贝（Deep Copy）
编程语言中浅拷贝（Shallow Copy）和深拷贝（Deep Copy）概念及JavaScript、Python、C++、Java深拷贝和浅拷贝情况介绍。
浅拷贝和深拷贝
浅拷贝（Shallow Copy）
浅拷贝是指创建一个新的对象，并将原始对象的属性值复制到新对象的过程。但是，如果属性是引用类型（如对象、数组、类实例等），浅拷贝将复制引用而不是引用的实际对象。因此，原始对象及其浅拷贝会共享那些引用类型的属性。对其中一个对象的引用类型属性所做的修改将影响另一个对象。
【浅拷贝（Shallow Copy）是创建一个新对象，该对象是原始对象的一级复制（"浅"到一层，即只"浅"到最外一层，不会递归地复制嵌套的对象结构）。具体来说：
对于基本数据类型的属性，复制其值。
对于引用类型的属性，复制引用（内存地址），而不是引用的对象本身。】
这意味着新对象和原始对象共享嵌套的引用类型数据。修改原始对象中的嵌套对象会影响新对象，反之亦然。
下面用JavaScript示例说明：
JavaScript示例说明：
let original = {
name: "John",
age: 30,
address: {
city: "New York",
country: "USA"
}
};
let shallowCopy = Object.assign({}, original);
original.age = 31;
original.address.city = "Los Angeles";
console.log(shallowCopy.age); // 30 (不受影响)
console.log(shallowCopy.address.city); // "Los Angeles" (受影响)
在这个例子中：
age 是原始数据类型，浅拷贝创建了独立的副本。
address 是引用数据类型，浅拷贝只复制了引用，所以原始对象的修改会影响到浅拷贝对象。
深拷贝（Deep Copy）
深拷贝是指创建一个新的对象，并将原始对象的属性值及其所有子对象（递归地）复制到新对象的过程。这意味着新对象拥有原始对象的一个完全独立的副本。对深拷贝对象的任何修改都不会影响原始对象，反之亦然。
【深拷贝（Deep Copy）是创建一个新对象，该对象是原始对象的完整复制，包括所有嵌套的对象结构。具体来说：
递归地复制原始对象中的所有属性。
对于基本数据类型的属性，复制其值。
对于引用类型的属性，创建新的对象或数组，并递归地复制其内容。
这样，新对象和原始对象完全独立，修改一个不会影响另一个。】
下面用JavaScript示例说明：在 JavaScript 中，我们可以使用 JSON.parse(JSON.stringify()) 方法来实现简单的深拷贝，或者使用递归函数来处理更复杂的情况。
先看使用 JSON.parse(JSON.stringify())，源码如下：
let original = {
name: "John",
age: 30,
address: {
city: "New York",
country: "USA"
},
hobbies: ["reading", "swimming"]
};
// 深拷贝
let deepCopy = JSON.parse(JSON.stringify(original));
// 修改原始对象
original.age = 31;
original.address.city = "Los Angeles";
original.hobbies.push("running");
// 输出比较
console.log("Original:", original);
console.log("Deep Copy:", deepCopy);
// 验证深拷贝效果
console.log("Age (Original):", original.age); // 31
console.log("Age (Deep Copy):", deepCopy.age); // 30
console.log("City (Original):", original.address.city); // Los Angeles
console.log("City (Deep Copy):", deepCopy.address.city); // New York
console.log("Hobbies (Original):", original.hobbies); // ["reading", "swimming", "running"]
console.log("Hobbies (Deep Copy):", deepCopy.hobbies); // ["reading", "swimming"]
再看使用递归函数（处理更复杂的情况，如循环引用），源码如下：
// 函数
function performDeepCopy(obj) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
let copy = Array.isArray(obj) ? [] : {};
for (let key in obj) {
if (obj.hasOwnProperty(key)) {
copy[key] = performDeepCopy(obj[key]);
}
}
return copy;
}
let original = {
name: "John",
age: 30,
address: {
city: "New York",
country: "USA"
},
hobbies: ["reading", "swimming"],
job: {
title: "Developer",
company: {
name: "Tech Corp",
location: "Downtown"
}
}
};
// 深拷贝
let deepCopy = performDeepCopy(original);
// 修改原始对象
original.age = 31;
original.address.city = "Los Angeles";
original.hobbies.push("running");
original.job.company.name = "New Tech Corp";
// 输出比较
console.log("Original:", original);
console.log("Deep Copy:", deepCopy);
// 验证深拷贝效果
console.log("Age (Original):", original.age); // 31
console.log("Age (Deep Copy):", deepCopy.age); // 30
console.log("City (Original):", original.address.city); // Los Angeles
console.log("City (Deep Copy):", deepCopy.address.city); // New York
console.log("Hobbies (Original):", original.hobbies); // ["reading", "swimming", "running"]
console.log("Hobbies (Deep Copy):", deepCopy.hobbies); // ["reading", "swimming"]
console.log("Company (Original):", original.job.company.name); // New Tech Corp
console.log("Company (Deep Copy):", deepCopy.job.company.name); // Tech Corp
这两个例子都展示了深拷贝的效果：
所有嵌套层级的数据都被完全复制。
修改原始对象的任何部分（包括嵌套对象和数组）不会影响深拷贝对象。
注意：
JSON.parse(JSON.stringify()) 方法简单易用，但有局限性：不能处理函数、undefined、Symbol 等。
递归方法更灵活，可以处理更复杂的对象结构，但需要注意处理循环引用的情况。
浅拷贝（Shallow Copy）和深拷贝（Deep Copy）这两个概念在不同的编程语言中应用时保持一致，只是实现细节和方法有所差异。
JavaScript、Python、C++、Java深拷贝和浅拷贝情况介绍
JavaScript
JavaScript 中的深拷贝和浅拷贝是处理对象复制时的两种不同方法。这两种方法在复制嵌套对象时表现出显著差异。
浅拷贝 (Shallow Copy)
浅拷贝创建一个新对象，其属性是原始对象属性的副本。如果属性是原始值，则复制其值；如果属性是对象引用，则复制引用而不是引用的对象。
特点：
只复制对象的第一层属性。
嵌套对象仍然共享相同的引用。
方法：
a) Object.assign()
// 浅拷贝示例
const obj1 = { a: 1, b: { c: 2 } };
// 使用 Object.assign 进行浅拷贝
const obj2 = Object.assign({}, obj1);
// 修改 obj1 中的嵌套对象
obj1.b.c = 42;
console.log(obj1); // 输出: { a: 1, b: { c: 42 } }
console.log(obj2); // 输出: { a: 1, b: { c: 42 } } (受影响)
在这个例子中，obj2 是 obj1 的浅拷贝，修改嵌套对象的属性会影响到 obj2。
b) 展开运算符
扩展运算符 ... 也称为剩余运算符
const myObj = { a: 1, b: 2, c: 3, d: 4 };
const { a, b, ...rest } = myObj;
console.log(a, b); // 1 2
console.log(rest); // { c: 3, d: 4 }
在这个例子中，扩展运算符可以轻松地提取对象中指定的属性，并将其余的属性作为一个新的对象返回。
c) Array.slice() (用于数组)
let originalArray = [1, [2, 3]];
let shallowCopyArray = originalArray.slice();
console.log(shallowCopyArray); // [1, [2, 3]]
slice() 是JavaScript中数组的一个方法，它可以用来创建一个数组的浅拷贝，并选择性地提取出该数组中的一段元素，而不会改变原始数组。
深拷贝 (Deep Copy)
深拷贝创建一个新对象，并递归地复制原始对象的所有嵌套对象，创建全新的副本。
特点：
创建对象及其所有嵌套对象的全新副本。
修改副本不会影响原始对象的任何部分。
方法：
JSON.parse() 和 JSON.stringify()：
// 深拷贝示例
const obj1 = { a: 1, b: { c: 2 } };
// 使用 JSON 方法进行深拷贝
const obj2 = JSON.parse(JSON.stringify(obj1));
// 修改 obj1 中的嵌套对象
obj1.b.c = 42;
console.log(obj1); // 输出: { a: 1, b: { c: 42 } }
console.log(obj2); // 输出: { a: 1, b: { c: 2 } } (未受影响)
在这个例子中，obj2 是 obj1 的深拷贝，修改嵌套对象的属性不会影响到 obj2。
JSON.parse(JSON.stringify()) 方法有局限性：
不能复制函数、undefined、Symbol
不能处理循环引用
可能丢失原型链
b) 递归函数
function deepClone(obj) {
if (obj === null || typeof obj !== 'object') {
return obj;
}
if (Array.isArray(obj)) {
return obj.map(deepClone);
}
const clonedObj = {};
for (let key in obj) {
if (obj.hasOwnProperty(key)) {
clonedObj[key] = deepClone(obj[key]);
}
}
return clonedObj;
}
const obj1 = { a: 1, b: { c: 2 } };
const obj2 = deepClone(obj1);
obj1.b.c = 42;
console.log(obj1); // 输出: { a: 1, b: { c: 42 } }
console.log(obj2); // 输出: { a: 1, b: { c: 2 } }
c) 使用第三方库，在此就不多说了。
JavaScript 中的深拷贝和浅拷贝更多情况，详见
https://developer.mozilla.org/zh-CN/docs/Glossary/Shallow_copy
https://developer.mozilla.org/zh-CN/docs/Glossary/Deep_copy
Python
在 Python 中，可以使用 copy 模块的 copy 函数进行浅拷贝， 使用deepcopy 函数进行深拷贝。
copy --- 浅复制和深复制操作 https://docs.python.org/zh-cn/3/library/copy.html
浅拷贝：
使用 copy.copy() 或对象的 copy() 方法
创建新对象，但内部引用仍指向原始对象的内存地址
深拷贝：
使用 copy.deepcopy()
递归地复制对象及其所有嵌套对象
示例：
import copy
original = [1, [2, 3], 4]
shallow = copy.copy(original)
deep = copy.deepcopy(original)
original[1][0] = 'X'
print(shallow) # [1, ['X', 3], 4]
print(deep) # [1, [2, 3], 4]
C++
在 C++ 中，通过复制构造函数和赋值运算符可以实现对象的深拷贝和浅拷贝。
浅拷贝：
默认的拷贝构造函数和赋值运算符通常执行浅拷贝
复制对象的成员变量，但不复制指针指向的数据
深拷贝：
需要自定义拷贝构造函数和赋值运算符
需要显式分配新内存并复制所有数据
示例：
#include <iostream>
#include <cstring>
class MyClass {
private:
int* data;
public:
// 构造函数
MyClass(int value) {
data = new int;
*data = value;
std::cout << "Constructor called, value: " << *data << std::endl;
}
// 复制构造函数（用于深拷贝）
MyClass(const MyClass& other) {
data = new int;
*data = *(other.data);
std::cout << "Copy constructor called, value: " << *data << std::endl;
}
// 赋值运算符（用于深拷贝）
MyClass& operator=(const MyClass& other) {
if (this == &other) {
return *this; // 防止自我赋值
}
delete data; // 删除旧数据
data = new int;
*data = *(other.data);
std::cout << "Assignment operator called, value: " << *data << std::endl;
return *this;
}
// 获取数据
int getValue() const {
return *data;
}
// 析构函数
~MyClass() {
delete data;
std::cout << "Destructor called" << std::endl;
}
};
int main() {
MyClass obj1(42); // 使用构造函数创建对象
MyClass obj2 = obj1; // 使用复制构造函数进行深拷贝
MyClass obj3(0);
obj3 = obj1; // 使用赋值运算符进行深拷贝
std::cout << "obj1 value: " << obj1.getValue() << std::endl;
std::cout << "obj2 value: " << obj2.getValue() << std::endl;
std::cout << "obj3 value: " << obj3.getValue() << std::endl;
return 0;
}
首先，定义一个简单的类 MyClass，在这个类中，我们定义了一个指向 int 类型的指针 data，并实现了以下几个函数：
构造函数，用于初始化对象。
复制构造函数，用于深拷贝，在创建新对象时复制另一个对象的数据。
赋值运算符，用于深拷贝，在将一个对象赋值给另一个对象时复制数据。
析构函数，用于释放动态分配的内存。
接下来，我们可以编写一个简单的主函数来测试深拷贝和浅拷贝的行为。创建了三个 MyClass 对象，并进行了深拷贝。输出将显示构造函数、复制构造函数、赋值运算符和析构函数的调用情况，验证深拷贝是否正确进行。
在深拷贝过程中，每个对象都有自己独立的内存空间，即使修改其中一个对象的数据，也不会影响其他对象。而浅拷贝只会复制指针的值，不会复制指针所指向的内存，这样多个对象会共享同一块内存，可能导致意外的行为。
输出：
Constructor called, value: 42
Copy constructor called, value: 42
Constructor called, value: 0
Assignment operator called, value: 42
obj1 value: 42
obj2 value: 42
obj3 value: 42
Destructor called
Destructor called
Destructor called
Java
在 Java 中，可以通过实现 Cloneable 接口和重写 clone 方法来实现对象的深拷贝和浅拷贝。
浅拷贝：
默认的 Object.clone() 方法执行浅拷贝
复制对象的引用，而不是对象本身
深拷贝：
需要实现 Cloneable 接口并重写 clone() 方法
对于复杂对象，可能需要递归克隆所有成员
示例：
包括两个文件：
第一个文件MyClass.java：
class MyClass implements Cloneable {
private int[] data;
// 构造函数
public MyClass(int size) {
data = new int[size];
for (int i = 0; i < size; i++) {
data[i] = i;
}
}
// 浅拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
// 深拷贝
protected MyClass deepClone() throws CloneNotSupportedException {
MyClass cloned = (MyClass) super.clone();
cloned.data = data.clone();
return cloned;
}
// 获取数据
public int[] getData() {
return data;
}
// 设置数据
public void setData(int index, int value) {
data[index] = value;
}
}
第二个文件Main.java：
public class Main {
public static void main(String[] args) {
try {
MyClass obj1 = new MyClass(5); // 使用构造函数创建对象
MyClass obj2 = (MyClass) obj1.clone(); // 使用浅拷贝
MyClass obj3 = obj1.deepClone(); // 使用深拷贝
// 修改 obj1 的数据
obj1.setData(0, 42);
System.out.println("obj1 data: " + java.util.Arrays.toString(obj1.getData()));
System.out.println("obj2 data: " + java.util.Arrays.toString(obj2.getData()));
System.out.println("obj3 data: " + java.util.Arrays.toString(obj3.getData()));
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
首先，定义一个简单的类 MyClass，在这个类中，我们实现了以下几个函数：
构造函数，用于初始化对象。
clone 方法，用于浅拷贝，通过调用 super.clone() 实现。
deepClone 方法，用于深拷贝，通过调用 super.clone() 并对成员变量进行克隆实现。
接下来，我们可以编写一个简单的主函数来测试深拷贝和浅拷贝的行为，创建了三个 MyClass 对象，并分别进行了浅拷贝和深拷贝。输出将显示各个对象的数据，验证浅拷贝和深拷贝是否正确进行。
浅拷贝的 obj2 和 obj1 共享同一个数组，因此修改 obj1 的数据会影响 obj2 的数据。而深拷贝的 obj3 有自己独立的数组，因此修改 obj1 的数据不会影响 obj3 的数据。
输出：
obj1 data: [42, 1, 2, 3, 4]
obj2 data: [42, 1, 2, 3, 4]
obj3 data: [0, 1, 2, 3, 4]
