深拷贝与浅拷贝

内存与数据类型

首先我们要知道内存是存储数据的，不同类型的数据要存储在不同的区域,而内存又分为栈区和堆区。

基本数据类型存储在栈内存，存储的是值
基本数据类型有六种，分别是undefined，null，bool，string，number，symbol（ES6新增）

复杂数据类型的值存储在堆内存，地址（指向真实数据）存储在栈内存，当我们把对象赋值给另外一个变量的时候，赋值的是地址，指向同一块内存，当一个对象改变时，另外一个也会变化
引用数据类型：object（类型）、array（数组）、function（函数）、Date、RegExp等。

简单来说，浅复制只复制一层对象的属性，而深复制则递归复制了所有层级。

什么是深拷贝和浅拷贝

浅拷贝：

对内存地址的复制，让目标对象指针和源对象指向同一片内存空间。注意：当内存销毁的时候，指向对象的指针，必须重新定义，才能够使用
a.基本类型–名值存储在栈内存中，例如let a=1;

    栈内存
name  |  val
 a    |   1

当你b=a复制时，栈内存会新开辟一个内存，例如这样：

   栈内存
name  |  val
 a    |   1
 b    |   1

所以当你此时修改a=2，对b并不会造成影响，因为此时的b已自食其力，翅膀硬了，不受a的影响了。当然，let a=1,b=a;虽然b不受a影响，但这也算不上深拷贝，因为深拷贝本身只针对较为复杂的object类型数据。
b.引用数据类型–名存在栈内存中，值存在于堆内存中，但是栈内存会提供一个引用的地址指向堆内存中的值，我们以上面浅拷贝的例子画个图：

     栈内存                                堆内存
name  |    val        =======>              val
 a    |   堆地址1						[0,1,2,3,4]

当b=a进行拷贝时，其实复制的是a的引用地址，而并非堆里面的值。

   栈内存                                  堆内存
name  |    val        		                val
 a    |   堆地址1		=======>  		
 										[0,1,2,3,4]
 b    |   堆地址2		=======> 

而当我们a[0]=1时进行数组修改时，由于a与b指向的是同一个地址，所以自然b也受了影响，这就是所谓的浅拷贝了。

   栈内存                                  堆内存
name  |    val        		                val
 a    |   堆地址1		=======>  		
 										[1,1,2,3,4]
 b    |   堆地址2		=======> 

那，要是在堆内存中也开辟一个新的内存专门为b存放值，就像基本类型那样，岂不就达到深拷贝的效果了

   栈内存                                  堆内存
name  |    val        		                val
 a    |   堆地址1		=======>  		[0,1,2,3,4]
 										
 b    |   堆地址2		=======>	    [0,1,2,3,4]

深拷贝例子:

1. 利用递归

function deepClone(obj){
    let objClone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj==="object"){
        for(key in obj){
            // 只拷贝obj内部的子元素
            if(obj.hasOwnProperty(key)){
                //判断ojb子元素是否为对象，如果是，递归复制
                if(obj[key]&&typeof obj[key] ==="object"){
                    objClone[key] = deepClone(obj[key]);
                }else{
                    //如果不是，简单复制
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
}    
let a=[1,2,3,4],
    b=deepClone(a);
a[0]=2;
console.log(a,b); // 可以发现a[0]的值和b[0]的值不同

2. 除了递归，我们还可以借用JSON对象的parse和stringify

function deepClone(obj){
    let _obj = JSON.stringify(obj),
        objClone = JSON.parse(_obj);
    return objClone
}    
let a=[0,1,[2,3],4],
    b=deepClone(a);
a[0]=1;
a[2][0]=1;
console.log(a,b);

3. 除了上面两种方法之外，我们还可以借用JQ的extend方法。
   $.extend( [deep ], target, object1 [, objectN ] )
   deep表示是否深拷贝，为true为深拷贝，为false，则为浅拷贝
   target Object类型 目标对象，其他对象的成员属性将被附加到该对象上。
   object1 objectN可选。 Object类型 第一个以及第N个被合并的对象。

let a=[0,1,[2,3],4],
    b=$.extend(true,[],a);
a[0]=1;
a[2][0]=1;
console.log(a,b)