面试的时候，经常会被问到js的浅拷贝和深拷贝问题，很多时候能够想清楚是怎么回事，但是实在描述不出来，可能还是自己比较差，今天看了好多关于深浅拷贝的博客，其中 有一篇很全面，这里把网页地址贴出来，
关于JavaScript的浅拷贝和深拷贝
我自己也通过学习做了一些总结，emmmmm，不知道要怎么说了，开始吧！
1.关于浅拷贝和深拷贝，首先要了解一下栈(stack)和堆(heap)
栈(stack)和堆(heap)
空间分配：
栈：为操作系统自动分配的内存空间，他由系统自动释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈，先进后出。
堆：动态分配的内存，大小不定也不会自动释放，队列优先,先进先出。
缓存方式：
栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。
堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
2.接下来，我们再来说一下 基本类型和引用类型
基本类型和引用类型
基本类型：存放在栈内存中的简单数据段，数据大小确定，内存空间大小可以分配。
基本类型有：Number，String，Boolean，Null，Undefined；它们是直接按值存放的，所以可以直接访问；
引用类型：存放在堆内存中的对象，变量实际保存的是一个指针，这个指针指向另一个位置，每个空间大小都不一样，要根据情况进行特定的分配。
引用类型有：对象（object），数组（array），函数（function），当我们要访问引用类型的值时，首先要先从栈中读取内存地址， 然后再通过地址找到堆中的值。
3.传值与传址
test：
<script>
var a = [1,2,3,4,5];
var b = a;
var c = a[0];
console.log(b);
console.log(c);
//改变数值
b[4]=8;
c=7;
console.log(a);
console.log(b);
console.log(c);
</script>
如图所示，改变变量b中的数据时，a中的数据也发生了变化，而改变c的值，a没有发生任何变化，只有c的值发生了改变。
原因很简单，因为a为数组，属于引用类型，所以它赋值给b传递的只是存储在栈中的地址（相当于创建了一个不同名的指针指向a指向的堆内存空间），而c只是从a堆内存中获取的一个数据值，保存在栈中，（相当于重新开辟了一块内存空间）所以修改b的值时，会根据地址回到a堆中进行修改，而c直接在栈中修改，并且不指向a堆内存中。
用一张图总结一下：
4.要正式开始说浅拷贝和深拷贝了，浅拷贝和深拷贝主要是对于引用类型
浅拷贝只复制指向某个对象的指针，但是还是共用同一块内存空间，修改新对象会修改旧对象，而深拷贝会创造另一个一模一样的对象，新对象和旧对象不共享内存，修改新对象不会改到旧对象。
（一）浅拷贝
在定义一个对象数组时，变量存放的往往只是一个地址，当我们使用对象拷贝时，如果属性是对象或者数组时，这是我们传递的也只是一个地址，因此对象在访问该属性时，会根据地址回溯到父对象的堆内存中，即父子对象发生了关联，两者的属性值会指向同一块内存空间。
（1）
test1：
<script>
var a ={key1:"111111"};
function Copy(p){
var c = {};
for(var i in p){
c[i]=p[i];
}
console.log(c);//object{key1: "111111", key2: Array(2)}
return c;
}
a.key2=["喵喵","喵"];
var b = Copy(a);
b.key3="333333";
console.log(b);//object{key1: "111111", key2: Array(2), key3: "333333"}
console.log(a);//object{key1: "111111", key2: Array(2)}
b.key2.push("喵喵喵");
console.log(b);//object{key1: "111111", key2: Array(3), key3: "333333"}
console.log(a);//object{key1: "111111", key2: Array(3)}
</script>
a对象中的key1的属性是字符串，key2的属性是数组，将a拷贝到b，key1,key2的值均可顺利拷贝，给b新增一个字符串类型的属性key3时，b能正常修改，而a中无定义;当给b对象的key2属性数组增加一个数值时，a对象的key2属性的值也发生改变；
（2）object.assign();
es6新函数，object.assign()可以把任意多个的源对象的可枚举属性拷贝给目标对象，然后返回目标对象，相当于对象合并，但是object.assign()进行的只是浅拷贝，拷贝的是对象的属性的引用，而不是对象本身。
object.assign(target,...source);
target：目标对象；
source：任意多个源对象；
返回值：目标对象
test2：
<script>
"use strict";
var obj = {a:1};
var copy =Object.assign({},obj);
console.log(copy);//{a:1};
var obj = { a: {a: "hello", b: 21} };
var initalObj = Object.assign({}, obj);
initalObj.a.a = "changed";
console.log(obj.a.a); // "changed"
</script>
（二）深拷贝
要完全复制又不能修改到原对象，这时候就要用 Deep Copy，创造另一个一模一样的对象，新对象和旧对象不共享内存，修改新对象不会改到旧对象。
（1）Object.assign()可以处理一层对象的深拷贝；
<script>
var obj1 ={a:10,b:20,c:30};
var obj2 =Object.assign({},obj1);
obj2.b = 50;
console.log(obj1);//{a:10,b:20,c:30}
console.log(obj2);//{a:10,b:50,c:30}
</script>
Object.assign({},source);先建立一个kogduixiang空对象{}，接着把obj1中所有的属性复制过去，所以obj2会长得跟obj1一样，这时候再修改obj2.b也不会影响obj1。
（2）递归方法进行深拷贝；
test:
<script>
function deepCopy(initalobj,finalobj){
var obj = finalobj||{};
for(var i in initalobj){
if(typeof initalobj[i] ==="object"){
obj[i]=(initalobj[i].constructor===Array)?[]:{};
deepCopy(initalobj[i],obj[i]);
}
else{
obj[i]=initalobj[i];
}
}
return obj;
}
var obj ={a:{a:"hello",b:10}};
var str =deepCopy(obj,str);
console.log(str);//{a:{a: "changed", b: 10}}
str.a.a="changed";
console.log(str);//{a:{a: "changed", b: 10}}
console.log(obj);//{a:{a:"hello",b:10}}
</script>
用递归函数进行深拷贝，首先函数deepCopy传入两个参数为原型对象和拷贝对象，在函数内部var一个变量obj将拷贝对象赋值给它，如果没有拷贝对象，则将一个空对象赋值给obj，然后对原始对象进行for...in遍历，判断每个属性的值是否嵌套，用constructor判断他是否为数组，然后再次调用函数，一直到它为一个单层对象时，赋值；接下来，改变拷贝对象的属性值，则不会影响原型对象。如例子所示，改变str的值，obj的值不会发生改变。
（3）转换成Json再转换回来（JSON.stringify()和JSON.parse()）
JSON.stringify() 方法是将一个JavaScript值(对象或者数组)转换为一个 JSON字符串,转化成字符串后就可以进行拷贝，则为值拷贝，会在栈内存空间中重新划分一块内存空间。
test：
<script>
var initalobj = {a:{b:3,c:5}};
var finalobj =JSON.parse(JSON.stringify(initalobj));
finalobj.a.b=8;
console.log(initalobj);//{a:{b:3,c:5}}
console.log(finalobj);//{a:{b:8,c:5}}
</script>
（4）使用Object.create()方法
直接使用var newObj = Object.create(oldObj)，可以达到深拷贝的效果。
test：
<script>
function deepCopy(initalobj,finalobj){
var obj = finalobj||{};
for(var i in initalobj){
var prop = initalobj[i]; // 避免相互引用对象导致死循环，如initalObj.a = initalObj的情况
if(prop===obj){
continue;
}
if(typeof prop === "object"){
obj[i]=(prop.constructor===Array)?[]:Object.create(prop);
alert("111");
}
else{
obj[i]=prop;
}
}
return obj;
}
var obj={a:{b:3,c:5}};
var newobj={};
deepCopy(obj,newobj);
console.log(obj);
newobj.a.b=9;
console.log(obj);
console.log(newobj);
</script>
(5)JQuery方法；$.extend();
<script>
var obj1 = {
a: 1,
b: { f: { g: 1 } },
c: [1, 2, 3]
};
var obj2 = $.extend(true, {}, obj1);
obj2.b.f.g=10;
console.log(obj1);
console.log(obj2);
console.log(obj1.b.f === obj2.b.f);
</script>
$.extend(true, {}, obj1)
(6)lodash
一个很热门的函数库lodash，也有提供_.cloneDeep用来做 Deep Copy。
var _ = require('lodash');
var obj1 = {
a: 1,
b: { f: { g: 1 } },
c: [1, 2, 3]
};
var obj2 = _.cloneDeep(obj1);
console.log(obj1.b.f === obj2.b.f);
// false
最后这个不太了解，知识面太窄，有兴趣的可以了解一下，当然我也会自己学习一下。
关于浅拷贝和深拷贝，就先写在这里了，下次见。
