深克隆和浅克隆

概括：深克隆和浅克隆 的主要区别就是：复制的是引用(地址)还是复制的是实例。
深克隆：主要复制的是实例，改变原对象，克隆的对象的内容不会随之改变，深克隆主要针对的是的例如Object，Array的复杂数据
浅克隆：主要复制的是引用的地址，改变原对象，克隆的对象会随之改变

浅克隆

数组的concat，对象的assign都是浅克隆
concat看起来很像深克隆，但是实质上他还是浅克隆，在Array.prototype.cancat 拷贝出来数组中的对象还是共享同一内存地址，所以本质上归属浅克隆

<script>
	var arr = [1,2,3,[2,3];
	var b = arr.concat();
	b[3][1] = 4;
	console.log(b)//[1,2,3[2,3]];
	var obj = {
		name: "lili",
		age : 12,
		a : {
			b : 1
		}
	} 
	var obj1 = obj;
	obj1.a.b = 3;
	console.log(obj.a.b);//3
</script>

深克隆

使用JSON.stringify实现深克隆

JSON.stringify方法可以将JS对象序列化成JSON字符串，JSON.parse方法可以将JSON字符串反序列化成JS对象，借助这两个方法，也可以实现对象的深克隆

<script>
	var obj2 = {
	       name:'lisa',
	       age:18,
	       info:{
	           job:'前端',
	           hobby:'敲代码'
	       }
	   };
	   var b = JSON.parse(JSON.stringify(obj2));
	   obj2.info.job = '明星';
	   console.log(obj2.info,b.info);
</script>

原生js实现深克隆

 <script>
    function Judge(param){
        //返回值为[object Array]  Array
        return Object.prototype.toString.call(param).slice(8,-1);
    }
    // console.log(Judge([1,2,3,3]))
    function clone(param){
        var result;
        // 判断是否为数组
        if(Judge(param) == 'Array'){
            result = [];
            // 判断是否为对象
        } else if(Judge(param) == 'Object'){
            result = {};
        } else{
            return param;
        }
        // 遍历数组里的值
        for(var i in param){
            var value = param[i];
            console.log(value);
            // 判断当前值是否为数组
            if(Judge(value) === 'Array' || Judge(value) === 'Object'){
                // 是数组就遍历里面的数
                result[i] = clone(value);
            }else {
                // 不是就直接赋值给result
                result[i] = value;
            }
        }
        return result;  
    }
    var arr = [5,2,3,4,{
        a : 3,
        b : 2
    },2,3,4];
        var arr1 = clone(arr);
        arr[4].a = 10;
        console.log(arr);
        console.log(arr1);

    // console.log(clone(['1234',1,2,32,[1,2,3]]));
</script>