js深复制和浅复制

2017-08-10 本文已影响67人葶寳寳

javaScript的变量类型

基本类型：
5种基本数据类型Undefined、Null、Boolean、Number 和 String，变量是直接按值存放的，存放在栈内存中的简单数据段，可以直接访问。
引用类型：
存放在堆内存中的对象，变量保存的是一个指针，这个指针指向另一个位置。当需要访问引用类型（如对象，数组等）的值时，首先从栈中获得该对象的地址指针，然后再从堆内存中取得所需的数据。

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

浅复制的实现

简单的引用复制

   var data = {a: 1, b: 2};
   var c = data;

Object.assign()
只会对第一层变量实现深复制；

var data =  {
  a: 1,
  b: { f: { g: 1 } },
  c: [ 1, 2, 3 ]
};

var objData = Object.assign({}, data);

console.log(objData === data); //false
console.log(objData.b.f === data.b.f); //true

Array的slice和concat方法（与Object.assign()方法是一样的）

Array的slice和concat方法不修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。它看起来像是深拷贝，而实际上它是浅拷贝。
例子如下：
```
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返回的不同的数组实例，这与直接的引用复制是不同的。

原数组的元素会按照下述规则拷贝：

如果该元素是个对象引用（不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

 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

可以看出Array的concat和slice并不是真正的深复制，数组中的对象元素(Object,Array等)只是复制了引用。

对于字符串、数字及布尔值来说（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

如果向两个数组任一中添加了新元素，则另一个不会受到影响。

var array = [1, 2, 3];

var array_shallow = array;
var array_concat = array.concat();
var array_slice = array.slice(0);

array.push(4);

console.log(array_concat); //[1, 2, 3]

深复制的实现

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));
target.name = "target";  //改变target的name属性

console.log(source.name); //source 
console.log(target.name); //target

target.child.name = "target child"; //改变target的child 
console.log(source.child.name); //child 
console.log(target.child.name); //target child

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

console.log(target.name); //undefined

var source = { name:function(){console.log(1);}, child:new RegExp("e") }
var target = JSON.parse(JSON.stringify(source));

console.log(target.name); //undefined
console.log(target.child); //Object {}

这种方法使用较为简单，可以满足基本的深拷贝需求，而且能够处理JSON格式能表示的所有数据类型，但是对于正则表达式类型、函数类型等无法进行深拷贝(而且会直接丢失相应的值)。

还有一点不好的地方是它会抛弃对象的constructor。也就是深拷贝之后，不管这个对象原来的构造函数是什么，在深拷贝之后都会变成Object。

如果对象中存在循环引用的情况也无法正确处理。

自定义方法实现深拷贝

function clone(data) {
    if (Array.isArray(data)) {
        let newArr = [];
        for (let i = 0; i < data.length; i++) {
            newArr[i] = clone(data[i]);
        }

        return newArr;
    } else if (data instanceof Object) {
        let obj = {};
        for (let key in data) {
            obj[key] = clone(data[[key]]);
        }
        return obj;
    }else {
        return data;
    }
}

var data =  {
    a: 1,
    b: { f: { g: 1 } },
    c: [ 1, 2, 3 ]
};

var objData = clone(data);
console.log(objData === data);  //false
console.log(objdata.b.f === data.b.f); //false