序言：
JS的复本(copy)，或许分成厚薄三种方式，原因是JS表达式的类别存有premitive（字面上量）与reference（提及）三种差别。总之，绝大多数C语言都存有这种优点。
不可否认，缓存包涵的内部结构中，有堆与栈。在JS里，字面上量类别表达式存放在栈中，存储的是它的值，而提及类别表达式虽然在栈中也占据内部空间，但存储的而已一个缓存门牌号（通过该门牌号能检索找出真实世界内部结构所处的缓存地区），它的真实世界内部结构是存有于堆中的。如下表所示图右图：
紧密结合库尔上看，一般而言，浅复本而已复本了缓存栈中的数据，深复本，则是要沿著提及类别表达式的真实世界缓存门牌号，去展开无数次的广度结点，直至复本完最终目标结点在栈与堆中的所有真实世界值。
一、浅复本的同时实现
JS同时实现了一些保有浅复本机能的USB，比如说重构表达式的rest商业模式、Object.assgin。
但浅复本的瑕疵是，展开复本之后，如果出现改变了被复本最终目标的某一提及优点的值，则复本结论的相关联优点的值也会发生出现改变，这般一来亦是这般。
比如说将example[嗜好][0]突显缓存数据 (玩游戏)，如下表所示图右图。
从其本质上而言，就原因是二者都对准同一缓存地区。原野缓存地区除非出现了发生变动，大自然二者算出的值都出现出现改变，而且完全一样。
二、深复本的同时实现
深复本的基本原理，前文早已描述过，但过分抽象化，还不如具体内容。
JS里，能借助原生植物的JSON格式化与反格式化USB女团展开同时实现深复本。
如下表所示图右图，深复本的结论与被复本的最终目标之间，早已彼此之间影响。
不过，JSON方式同时实现的深复本，有很多瑕疵，首先，是复本失真：
1. 值为undefined、函数、Symbol的优点，或者键为Symbol字符串的优点，复本后，优点会丢失。
2. 值为NaN的优点，复本后，值转为了null。
3. 值为非标准对象Object，比如说Set、Map、Error、RegExp等等的优点或数组元素，复本后，值转为了空的标准对象，丢失了原来的原型继承关系。
3. 值为undefined、NaN、函数的数组元素，复本后，值转为了null。
其次，是复本机能的瑕疵：
1. 原型链丢失
2. 无法复本有循环提及的对象
综上所述，要同时实现比较完整机能的深复本，就必须得兼顾JSON方式的功能和缺点。
三、手动同时实现深复本
追寻深复本的同时实现方式，能认知为：深复本 = 浅复本+广度结点+特殊情况容错。
以下，我们来同时实现一个深复本函数，deepCopy。假定函数接受的输入为o。
// 深复本函数 function deepCopy(o) { }
深复本的基本同时实现思路，从JS数据类别的角度出发，能先区分字面上量与提及三种类别的表达式。
然后，只要判断是字面上量，我们就直接浅复本返回，否则就进入广度结点，重复前面的浅复本，直至结点结束。
// 深复本函数 function deepCopy(o) { // 如果是字面上量，直接返回 if(isPrimitive(o)) return o; // 否则，展开深度结点 /** * 广度结点代码 */ }
我们先同时实现一个判断输入是否为字面上量的函数
function isPrimitive(o) { if (typeof o !== function && typeof o !== object) return true; if (o === null) return true; return false; }
然后，展开广度结点。广度结点一般有三种选择，一个是递归，一个是while循环。
递归很好认知，但有个瑕疵，大量函数栈帧的入栈，很容易导致缓存内部空间不足而爆栈，特别是对于有循环提及关系的输入，可能秒秒钟爆炸。这里，我们采用while循环。
采用while循环的话，我们能模拟一个栈内部结构，栈如果为空，则结束循环，若不为空，则展开循环，循环第一步，先出栈，然后处理数据，处理完之后，进入下一次循环判断。
在JS里，模拟栈内部结构能用数组，push与pop女团，完美实现后入先出。在数据内部结构与算法里，这叫广度优先。
// 深复本函数 function deepCopy(o) { // 如果是字面上量，直接返回; 否则，展开广度结点 if(isPrimitive(o)) return o; // 首先，先定义一个观察者，用来记录结点的结论。等到结点结束，这个观察者就是深复本的结论。 const observer = {}; // 然后，用数组模拟一个栈内部结构 const nodeList = []; // 其次，为了每次结点时能地做一些处理，入栈的数据用对象来表示比较合适。 nodeList.push({ key: null, // 这里，增加一个key优点，用来关联每次结点所要处理的数据。 }); // 循环结点 while(nodeList.length > 0) { const node = nodeList.pop(); // 出栈，广度优先 // 处理节点node } }
接下来，就是处理节点node了。这里要处理的任务，主要有：
1.特殊情况处理，比如说Symbol类别的优点虽然无法被Object.keys迭代出来，但能用Reflect.ownKeys来解决。又比如说，针对循环提及，能在循环外面建立哈希表，每次循环都判断要处理的输入是否已存有哈希表，如果存有，直接提及，否则，存入哈希表。
// 用WeakMap模拟的哈希表，它的弱提及优点能避免内存泄露 const hashmap = new WeakMap(); // 结点包括Symbol类别在内的所有优点 const keys = Reflect.ownKeys(node.value);
2.初始化，将输入o挂载到节点里，并存入哈希表。
// 初始化 if (node.key === null) { node.value = o; node.observer = observer // 存入哈希表 hashmap.set(node.value, node.observer) }
3.对节点的优点展开结点，优点值为提及类别，将它压入栈，否则，观察者借助关联的key记录优点值，然后进入下一次循环。
for (let i = 0; i < keys.length; i++) { key = keys[i]; value = node.value[key]; // 是字面上量，直接记录 if (isPrimitive(value)) { node.observer[key] = value; continue; } // 否则，入栈 nodeList.push({ key, value, observer: node.observer }) }
4.每次对节点优点展开结点前，先根据哈希表展开判断
// 查询哈希表，如果不存有对象key，就存入哈希表 if (!hashmap.has(node.value)) { hashmap.set(node.value, node.observer[node.key] = isArray(node.value) ? [] : {}); // 将对象压入栈 nodeList.push({ key: node.key, value: node.value, observer: node.observer[node.key] }) continue; } // 存有哈希表里，则从哈希表里取出，表达式 else if (node.observer !== hashmap.get(node.value)) { node.observer[node.key] = hashmap.get(node.value) continue; }
这里，补上isArray函数，用来判断是否为数组
function isArray(o) { return Object.prototype.toString.call(o) === [object Array]; }
到此，深复本函数早已成型了。但，还不如完善，因为还没有对输入是函数的情况做处理。
所以，添加两个函数，一个判断是否是函数，一个用例复本函数。
// 判断函数 function isFunction(o) { return Object.prototype.toString.call(o) === [object Function]; } // 复本函数 function copyFunction(fnc) { const f = eval(`(${fnc.toString()})`) Object.setPrototypeOf(f, Object.getPrototypeOf(fnc)) Object.keys(fnc).map(key => f[key] = deepCopy(fnc[key])) return f; }
循环结点之前，加一层对函数的判断
// 是函数，则复本函数 if (isFunction(o)) return copyFunction(o);
结点的时候，也要加一层对函数的判断
// 函数直接表达式
else if (isFunction(node.value)) { node.observer[node.key] = copyFunction(node.value) continue; }循环结束后，我们还要对原型链展开处理，深复本，不能把继承关系给弄丢，这也是输入无论是数组还是对象都能获得正确复本结论的一个技巧
// 继承原型 Object.setPrototypeOf(observer, Object.getPrototypeOf(o))
最后，返回观察者对象，即深复本结论。
// 返回深复本结论 return observer;
四、测试结论与结论
五、手动同时实现的深复本完整代码
// 判断字面上量
function isPrimitive(o) {
if (typeof o !== function && typeof o !== object) return true;
if (o === null) return true;
return false;
}
// 判断数组
function isArray(o) {
return Object.prototype.toString.call(o) === [object Array];
}
// 判断函数
function isFunction(o) {
return Object.prototype.toString.call(o) === [object Function];
}
// 复本函数
function copyFunction(fnc) {
const f = eval(`(${fnc.toString()})`)
Object.setPrototypeOf(f, Object.getPrototypeOf(fnc))
Object.keys(fnc).map(key => f[key] = deepCopy(fnc[key]))
return f;
}
// 哈希表
const hashmap = new WeakMap();
// 深复本函数
function deepCopy(o) {
// 如果是字面上量，直接返回; 否则，展开深度结点
if (isPrimitive(o)) return o;
// 是函数，则复本函数
if (isFunction(o)) return copyFunction(o);
// 首先，先定义一个观察者，用来记录结点的结论。等到结点结束，这个观察者就是深复本的结论。
const observer = {};
// 然后，用数组模拟一个栈内部结构
const nodeList = [];
// 其次，为了每次结点时能地做一些处理，入栈的数据用对象来表示比较合适。
nodeList.push({
key: null, // 这里，增加一个key优点，用来关联每次结点所要处理的数据。
});
// 提升表达式，尽量少在循环里创建表达式
let node;
let keys;
let key;
let value;
// 循环结点
while (nodeList.length > 0) {
node = nodeList.pop(); // 出栈，广度优先
// 处理节点node
// 初始化
if (node.key === null) {
node.value = o;
node.observer = observer
// 存入哈希表
hashmap.set(node.value, node.observer)
}
// 是函数，则直接记录
else if (isFunction(node.value)) {
node.observer[node.key] = copyFunction(node.value)
continue;
}
// 查询哈希表，如果不存有对象key，就存入哈希表
else if (!hashmap.has(node.value)) {
hashmap.set(node.value, node.observer[node.key] = isArray(node.value) ? [] : {});
// 是对象，入栈
nodeList.push({
key: node.key,
value: node.value,
observer: node.observer[node.key]
})
continue;
}
// 存有哈希表里，则从哈希表里取出，表达式
else if (node.observer !== hashmap.get(node.value)) {
node.observer[node.key] = hashmap.get(node.value)
continue;
}
// 结点包括Symbol类别的所有优点
keys = Reflect.ownKeys(node.value);
for (let i = 0; i < keys.length; i++) {
key = keys[i];
value = node.value[key];
// 是字面上量，直接存储
if (isPrimitive(value)) {
node.observer[key] = value;
continue;
}
// 否则，入栈
nodeList.push({
key,
value,
observer: node.observer
})
}
}
// 继承原型
Object.setPrototypeOf(observer, Object.getPrototypeOf(o))
// 返回深复本结论
return observer;
}我组建了一个后端自学团，自学后端技术。在团里，会严格监督大家每天自学打卡，给大家分享自学资料，给大家匹配自学伙伴，定期组织大家展开项目实战。想要加入一起自学的小伙伴能私信我或是给我留言。
作者：千無
链接：认知JS深复本
