深拷贝和浅拷贝的区分 以及 实现

浅拷贝：复制一层对象的属性，并不包括对象里面的为引用类型的数据，当改变拷贝的对象里面的引用类型时，源对象也会改变。

深拷贝：从新开辟一个内存空间，须要递归拷贝对象里的引用，直到子属性都为基本类型。两个对象对应两个不一样的地址，修改一个对象的属性，不会改变另外一个对象的属性。

1.JavaScript 的变量类型

基本类型：undefined null number boolen string symbol 变量是直接按值存放的，存放在栈内存中的简单数据段，能够直接访问

引用类型：Object, Array,Function,Date,存放在堆内存中的对象，变量保存的是一个指针，这个指针指向另外一个位置。当须要访问引用类型（如对象，数组等）的值时，首先从栈中得到该对象的地址指针，而后再从堆内存中取得所需的数据。

基本类型和引用类型的区别：1：内存空间（栈内存和堆内存）   2：对值的操做   3：变量的复制

JavaScript存储对象都是存地址的，因此浅拷贝会致使 obj1 和obj2 指向同一块内存地址。改变了其中一方的内容，都是在原来的内存上作修改会致使拷贝对象和源对象都发生改变，而深拷贝是开辟一块新的内存地址，将原对象的各个属性逐个复制进去。对拷贝对象和源对象各自的操做互不影响。

eg: 数组的拷贝 

// 浅拷贝，指向的是同一片内存
	let arr1 = [1,2,3,4];
	let arr2 = arr1;
	arr2[0] = 5;
	console.log(arr1); // [5,2,3,4]
	console.log(arr2); // [5,2,3,4]

浅拷贝和深拷贝的区分

深复制和浅复制只针对像 Object, Array，Date 这样的复杂对象的。简单来讲，浅复制只复制一层对象的属性，而深复制则递归复制了全部层级。

function copy(obj) {
   var newObj = {};
   for (let key in obj) {
	newObj[key] = obj[key];
   }
   return newObj;
}
var obj = {name: 'TOM', arr: [1,2,3]};
var end = copy(obj);

由于浅复制只会将对象的各个属性进行依次复制，并不会进行递归复制，而 JavaScript 存储对象都是存地址的，因此浅复制会致使 obj.arr 和 end.arr 指向同一块内存地址

end.arr[0] = 5;
console.log(obj.arr); // [5,2,3]
console.log(end.arr); // [5,2,3]

所以修改了end对象 可是obj对象也跟着变了

浅拷贝的实现 

简单的引用复制 

function copy(copyObj) {
  var obj = {};
  for ( var i in copyObj) {
    obj[i] = copyObj[i];
  }
  return obj;
}
var x = {
  a: 1,
  b: { f: { g: 1 } },
  c: [ 1, 2, 3 ]
};
var y = copy(x);
console.log(y.b.f === x.b.f);     // true

Object.assign() 

Object.assign() 方法能够把任意多个的源对象自身的可枚举属性拷贝给目标对象，而后返回目标对象。 

var x = {
  a: 1,
  b: { f: { g: 1 } },
  c: [ 1, 2, 3 ]
};
var y = Object.assign({}, x);
console.log(y.b.f === x.b.f);     // true

深拷贝的实现 

Array的slice和concat方法 

Array的slice和concat方法不修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。之因此把它放在深拷贝里，是由于它看起来像是深拷贝。而实际上它是浅拷贝。原数组的元素会按照下述规则拷贝： 

• 若是该元素是个对象引用 （不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。若是被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。
• 对于字符串、数字及布尔值来讲（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另外一个数组。

 若是向两个数组任一中添加了新元素，则另外一个不会受到影响。例子以下： 

var array = [1,2,3]; 
var array_shallow = array; 
var array_concat = array.concat(); 
var array_slice = array.slice(0); 
console.log(array === array_shallow); //true 
console.log(array === array_slice); //false，“看起来”像深拷贝
console.log(array === array_concat); //false，“看起来”像深拷贝

 能够看出，concat和slice返回的不一样的数组实例，这与直接的引用复制是不一样的。而从另外一个例子能够看出Array的concat和slice并非真正的深复制，数组中的对象元素(Object,Array等)只是复制了引用。以下： 

//code from http://caibaojian.com/javascript-object-clone.html#comments
var array = [1, [1,2,3], {name:"array"}]; 
var array_concat = array.concat();
var array_slice = array.slice(0);
array_concat[1][0] = 5;  //改变array_concat中数组元素的值 
console.log(array[1]); //[5,2,3] 
console.log(array_slice[1]); //[5,2,3] 
array_slice[2].name = "array_slice"; //改变array_slice中对象元素的值 
console.log(array[2].name); //array_slice
console.log(array_concat[2].name); //array_slice

JSON对象的parse和stringify 

JSON对象是ES5中引入的新的类型（支持的浏览器为IE8+），JSON对象parse方法能够将JSON字符串反序列化成JS对象，stringify方法能够将JS对象序列化成JSON字符串，借助这两个方法，也能够实现对象的深拷贝。 

var source = { name:"source", child:{ name:"child" } } 
var target = JSON.parse(JSON.stringify(source));

这种方法使用较为简单，能够知足基本的深拷贝需求，并且可以处理JSON格式能表示的全部数据类型，可是对于正则表达式类型、函数类型等没法进行深拷贝(并且会直接丢失相应的值)。还有一点很差的地方是它会抛弃对象的constructor。也就是深拷贝以后，无论这个对象原来的构造函数是什么，在深拷贝以后都会变成Object。同时若是对象中存在循环引用的状况也没法正确处理。

深度复制的彻底实现

Object.prototype.clone = function () {
var o = {};
for (var i in this) {
o[i] = this[i];
}
return o;
};
Array.prototype.clone = function () {
var arr = [];
for (var i = 0; i < this.length; i++)
if (typeof this[i] !== 'object') {
arr.push(this[i]);
} else {
arr.push(this[i].clone());
}
return arr;
};

//测试1 Object
var obj1 = {
name: 'Rattz',
age: 20,
hello: function () {
return "I'm " + name;
}
};
var obj2 = obj1.clone();
obj2.age++;
console.log(obj1.age);

//测试2 Array
var fun = function(log) {console.log},
arr1 = [1, 2, [3, 4], {a: 5, b: 6}, fun],
arr2 = arr1.clone();

console.log(arr1, arr2);

arr2[2][1]= 'Mike';
arr2[3].a = 50;
arr2[4] = 10;
console.log(arr1, arr2);

使用 jQuery 的 extend 方法

var arr1 = [1, 2, [3, 4], {a: 5, b: 6}, 7],
arr2 = $.extend(true, [], arr1);

console.log(arr1, arr2);
arr2[1] = 10;
console.log(arr1, arr2);

　　

来源：前端开发博客