JavaScript浅拷贝和深拷贝

一、数据类型

1.数据类型分类

要理解 JavaScript中浅拷贝和深拷贝的区别，首先要明白JavaScript的数据类型

JavaScript有两种数据类型，基础数据类型和引用数据类型

• 基础类型：undefined 、 null、number、string、boolean、symbol
• 引用类型：object对象类型(Object 、Array 、Function 、Data)

2.数据类型关键知识

• 基础类型是按照值进行访问的，可以操作保存在变量中的实际的值。
• 对于引用类型，javascript是不允许直接访问值的，不能直接操作对象的内存空间，在操作对象时候，实际操作是引用，而不是实际的引用。
• 基础类型存在于栈中
• 引用类型的值是同时保存在栈内存和堆内存中的对象。

3.不同数据类型的存放与复制

3.1存放

• a1 = 0; a2 = ‘this is str’; a3 = null
  存放在栈内存中
• var c =[1,2,3] ;var d = {m:20}
  变量名与内存地址存储在栈内存中
• [1,2,3]与{m:20}
  作为对象存储在堆内存中

3.2基础数据类型的复制

3.3引用数据类型的复制

m与n指向同一个内存空间，当m或者n改变时，另一个也跟着改变

二、浅拷贝

• 只复制指向某个对象的指针，而不复制对象本身，新旧对象共享一块内存；
• 浅复制只复制一层对象的属性，只会将对象的各个属性进行依次复制，并不会进行递归复制

1.简单的引用复制

function shallowClone(Obj) {
  var objClone = {};
  for ( var i in Obj) {
    obj[i] = objClone[i];
  }
  return obj;
}

2.Object.assign()

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

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

三、深拷贝

复制并创建一个一摸一样的对象，不共享内存，修改新对象，旧对象保持不变；

1.采用递归的方法复制拷贝对象

function deepclone1(obj) {
        let objClone = Array.isArray(obj) ? [] : {};
        if (obj && typeof obj === "object") {
            for (key in obj) {
                //if (obj.hasOwnProperty(key)) {   //也可以不加
                    if (obj[key] && typeof obj[key] === "object") {
                        objClone[key] = deepclone(obj[key])
                    } else {
                        objClone[key] = obj[key]
                    }
                //}
            }
        }
        return objClone
    }
    var a = [1, 2, 3, 4];
    var b = deepclone(a);
    a[0] = 8
    console.log(a, b);

2.JSON.stringify结合JSON.parse

 function deepclone2(obj){
      var _obj = JSON.stringify(obj);
      var cloneObj = JSON.parse(_obj);
      return cloneObj
    }
    var a =[1,2,3,4];
    var b= deepclone(a);
    a[0]=8
    console.log(a,b);
   

可以用JSON.stringify与JSON.parse实现深拷贝的原因是JSON.stringify(obj)转换成字符串，变成基本数据类型，基本类型拷贝是直接在栈内存新开空间，直接复制一份名-值，不影响之前的对象

**缺点：这种方法可以实现数组和对象和基本数据类型的深拷贝，但不能处理函数。**因为JSON.stringify()方法是将一个javascript值转换我一个JSON字符串，不能接受函数。其他影响如下：

• 对象中有时间对象，那么用该方法拷贝之后的对象中，时间是字符串形式而不是时间对象
• 如果对象中有RegExp、Error对象，那么序列化的结果是空
• 如果对象中有函数或者undefined，那么序列化的结果会把函数或undefined丢失
• 如果对象中有NAN、infinity、-infinity，那么序列化的结果会变成null
• JSON.stringfy（）只能序列化对象的可枚举自有属性，如果对象中有是构造函数生成的，那么拷贝后会丢弃对象的constructor
• 如果对象中存在循环引用也无法正确实现深拷贝

3.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等)只是复制了引用。如下：：

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

4.jQuery.extend()方法源码实现

var array = [1,2,3,4];
var newArray = $.extend(true,[],array); // true为深拷贝，false为浅拷贝

5.Reflect法

// 代理法
function deepClone(obj) {
    if (!isObject(obj)) {
        throw new Error('obj 不是一个对象！')
    }

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [...obj] : { ...obj }
    Reflect.ownKeys(cloneObj).forEach(key => {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    })

    return cloneObj
}

---

参考资料

JavaScript中浅拷贝和深拷贝的区别和实现
javascript中的深拷贝和浅拷贝区分以及实现