什么是浅拷贝和深拷贝？ - 网站源码_资源分享

以JS中的浅复本和深复本为例做个表明：

一.速识基本上概念：

第一类复本，具体而言是将第一类再拷贝这份，但，拷贝的方式相同Sonbhadra获得相同的结论。比如说间接给新表达式表达式为两个第一类：

// 1.建两个第一类 var obj = { name: “swzs之夜。”, like: “aurora”, }; // 2. 间接将第一类表达式给表达式 clone var clone =obj; // 3.修正obj的like特性 obj.like = “wind”; // 4.输入 clone 第一类 console.log(clone);

从输入结论能看见，我没错发生改变的是 obj 第一类的特性，但 clone 第一类的特性也发生改变了。这原因在于，当创建 obj 第一类时，它在堆缓存中开拓了几块内部空间储存第一类的文本。而当 clone 间接表达式为 obj 时，clone 并不能再再次开拓几块堆缓存，而要 obj 跟 clone 说我把我这缓存内部空间储存的第一类的门牌号给你，那个门牌号存有栈缓存中，你透过栈缓存的门牌号找出堆缓存里对象的文本，咱相连接就谁知了。因此说， obj 和 clone 对准的都是同几块文本，无论谁改了第一类的文本，自己再出访都是改过自新后的了。

因此这并非他们想的，我不该相连接，我想属于自己的一片片四海，我命由我无可奈何你，因此这就须要浅复本和深复本了。

单纯补足：像许多基本上正则表达式的表达式（Number Boolean String undefined null）被表达式时能间接在栈缓存中开拓出了两个捷伊储存地区用以储存捷伊表达式，不能如第一类那般而已把提及给自己。

二.浅复本基本上原理与常见方式：

单纯而言浅复本是只复本几层。甚么原意呢？比如说我有两个第一类 obj ：

var obj = { name: “swzs之夜。”, like: “aurora”, };

我要把它复本给表达式 b ，基本上原理是我再再次开拓几块缓存，然后我直接看 obj 里有甚么特性和值就间接拷贝这份，比如说透过如下方式实现：

// 1.建两个第一类 var obj = { name: “swzs之夜。”, like: “aurora”, }; // 2. 封装两个函数，实现传入两个第一类返回两个复本后的新第一类 function cloneObj(obj) { let clone = {}; // 3.用 for in 遍历obj的特性 for (let i in obj) {clone[i] = obj[i]; } return clone; } // 4.执行函数，将获得两个新第一类 var clone = cloneObj(obj); // 5.更改 obj 特性值 obj.like = “wind”; // 6.输入 console.log(clone);

结论：

能看见，是新建两个空第一类，还是循环间接表达式给它，这时发生改变 obj 的like特性值，新建的那个第一类也不受影响了。但，如果 obj 是下面这种形式的呢：

var obj = { name: “swzs之夜。”, like: “aurora“, num: { a: “1”, b: “2”, }, };

此时再用上面那种方式就不行了，如果obj只发生改变像 name 这种特性还没问题，但当 obj 发生改变得是像 num 这种提及类型（第一类、数组都是提及类型）的数据时，复本的第一类还是能被影响，因为浅复本只能复本几层，如果复本的第一类里还有子第一类的话，那子第一类复本其是也而已获得两个门牌号对准而已。这透过上面代码也能看出，就几层循环而已。想真的达到我命由我无可奈何天的话得用深复本，真正的刨根问底。深复本见第三大点。下面介绍下浅复本常见的方式，当第一类只有几层的时候还是用浅复本好。

浅复本常见的方式：

1.第一种是主要利用 for in 遍历原第一类的特性。

// 封装两个函数，实现传入两个第一类返回两个拷贝后的新第一类 function cloneObj(obj) { let clone = {}; // 用 for in 遍历obj的特性 for (let i in obj) { clone[i] = obj[i]; } return clone; }

2.能用Object.keys()方式：

Object.keys() 方式会返回两个由两个给定第一类的自身可枚举特性组成的数组。

function cloneObj(obj) { let clone = {}; for (let i of Object.keys(obj)) { clone[i] = obj[i]; } return clone; }

3.能用Object.entries()方式：

Object.entries()方式返回两个给定第一类自身可枚举特性的键值对数组。

function cloneObj(obj) { let clone = {}; for (let [key, value] of Object.entries(obj)) { clone[key] = value; } return clone; }

4.可用Object.getOwnPropertyNames（）配合forEach循环：

Object.getOwnPropertyNames（）返回两个由它的特性构成的数组。

function cloneObj(obj) { let clone = {}; Object.getOwnPropertyNames(obj).forEach(function (item) { clone[item] = obj[item]; }); return clone; }

5.可用Object.defineProperty()方式：

Object.defineProperty(obj, prop, descriptor) 方式会间接在两个第一类上定义两个新特性，或者修正两个第一类的现有特性，并返回此第一类。obj要定义特性的第一类。prop要定义或修正的特性的名称或 Symbol。descriptor要定义或修正的特性描述符。

Object.getOwnPropertyDescriptor()：返回指定第一类上两个自有特性对应的特性描述符。

特性描述符：JS 提供了两个内部数据结构，用以描述第一类的值、控制其行为。称为特性描述符。

function cloneObj(obj) { let clone = {}; Object.getOwnPro= Object.getOwnPropertyDescriptor(obj, item); // 把特性修饰符表达式给新第一类 Object.defineProperty(clone, item, des); }); return clone; }

还有很多方式，就不一一列举了

三.深复本常见方式：

深复本就不能像浅复本那般只复本几层，而要有多少层我就复本多少层，要真正的做到全部文本都放在自己新开拓的缓存里。能利用递归思想实现深复本。

1.能如下实现，还是用 for in 循环，如果为特性第一类则递归：

试一试看：

// 1.建两个第一类 var obj = { name: “swzs之夜。”, like: “aurora”, age: { a: 1, b: 2, }, }; // 2. 封装两个函数，实现传入两个第一类返回两个复本后的新第一类 function cloneObj(obj) { let clone = {}; for (let i in obj) { // 如果为第一类则递归更进几层去复本 if (typeof obj[i] == “object” && obj[i] != null) { clone[i] = cloneObj(obj[i]); } else { clone[i] = obj[i]; } } return clone; } // 4.执行函数，将获得两个新第一类 var clone = cloneObj(obj); // 5.更改 obj 特性值 obj.age.a = “666”; // 6.输入 console.log(clone);

结论如下，复本成功，原第一类发生改变无法使新第一类也发生改变：

2.如果第一类里面有数组怎么办，数组也跟第一类一样是提及类型，那么他们能在开头加个判断它是第一类还是数组，数组的话赋空数组，一样遍历复本：

function cloneObj(obj) { // 透过原型链判断 obj 是否为数组 if (obj instanceof Array) { var clone = []; } else { var clone = {}; } for (let i in obj) { // 如果为第一类则递归更进几层去复本 if (typeof obj[i] == “object” && obj[i] != null) { clone[i] = cloneObj(obj[i]); } else { clone[i] = obj[i]; } } return clone; }

试一试看：

结论没问题：