js 对象的深拷贝

我们使用=操作符复制对象时，由于对象是通过引用传递的，父子对象引用的是内存上同一个堆的地址，修改任意父子对象，父子对象都会改变，为了保证子对象修改不影响到父对象，需要进行深拷贝

var arr = ['1','2'];
var obj = {
    name:'yy',
    age:['1','2'], 
    ojbs: {
        value: 1, 
        text: '中国'
    },
    arrs:[{
        value: 3, 
        text: '江西'      
    },{
        value: 4, 
        text: '广东'      
    }]
};
obj.an = '1111';

数组深拷贝

var newArr = arr.slice(0);
var newArr2 = arr.concat();
newArr.push('4')
newArr2.push('4333')
console.log(newArr)
console.log(newArr2)

对象深拷贝

var deepCopyObj = function(obj ) { 
        var copy;
        
        // 处理3个简单的类型, null 或者 undefined
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }

        if (obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }

        if (obj instanceof Array) {
            var copy = [];
            for (var i = 0, len = obj.length; i < len; i++) {
                copy[i] = clone(obj[i]);
            }
            return copy;
        }

        if (obj instanceof Object) {
            var copy = {};
            for (var attr in obj) {
                if (obj.hasOwnProperty(attr)) {
                    copy[attr] = clone(obj[attr]);
                }
            }
            return copy;
        }

        throw new Error("Unable to copy obj! Its type isn't supported.");
}

console.time('deepCopyObj');  
var newObj = deepCopyObj(obj);
console.log(JSON.stringify(newObj))
console.timeEnd('deepCopyObj'); 

下面来总结一下实现深复制的的基本思路：
1.检测当前属性是否为对象
2.因为数组是特殊的对象，所以，在属性为对象的前提下还需要检测它是否为数组。
3.如果是数组，则创建一个[]空数组，否则，创建一个{}空对象，并赋值给子对象的当前属性。然后，递归调用extendDeep函数。
上面例子使我们自己使用递归算法实现的一种深度复制方法。事实上，ES5新增的JSON对象提供的两个方法也可以实现深度复制，
分别是JSON.stringify()和JSON.parse();前者用来将对象转成字符串，后者则把字符串转换成对象。下面我们使用该方法来实现一个深度复制的函数：

根据不包含引用对象的普通数组深拷贝得到启发，不拷贝引用对象，拷贝一个字符串会新辟一个新的存储地址，这样就切断了引用对象的指针联系。

console.time('JSON');
var newObj1 = JSON.parse(JSON.stringify(obj))
console.log(JSON.stringify(newObj1))
console.timeEnd('JSON'); 

测试发现，它也实现了深度复制。一般推荐使用后面这种方法，因为JSON.parse和JSON.stringify是内置函数，处理起来会比较快。
另外，前面的那种方法使用了递归调用，我们都知道，递归是效率比较低的一种算法。

newObj.name = 'xx';
newObj.age.push('3');
newObj.ojbs.value = 3;
newObj.ojbs.code = '10001';
newObj.arrs.push({value: 5,text: '河北'   });

newObj1.arrs.push({value: 5,text: '河北'  });
newObj1.arrs.push({value: 6,text: '北京'  });

console.log(JSON.stringify(obj))
console.log(JSON.stringify(newObj))
console.log(JSON.stringify(newObj1))

上面的方法完全能够Object、Array、Date、String、Number或者Boolean类型这6个简单类型的深拷贝，只要对象和数组中的数据形成一个树状结构，也就是说，在1个对象中没有多于1个的对相同数据的引用。例如:

// 这是可以克隆的
var tree = {
    "left": { "left": null, "right": null, "data": 3 },
    "right": null,
    "data": 8
};

// 这样也可以工作，但是你会得到2份内部节点，而不是2个引用相同的副本
var directedAcyclicGraph = {
    "left"  : { "left" : null, "right" : null, "data" : 3 },
    "data"  : 8
};

directedAcyclicGraph["right"] = directedAcyclicGraph["left"];

var newdirectedAcyclicGraph = clone(directedAcyclicGraph)
newdirectedAcyclicGraph.data = 9;
console.log(JSON.stringify(directedAcyclicGraph))
console.log(JSON.stringify(newdirectedAcyclicGraph))      

// 这种情况因为无限的递归，会导致堆栈溢出
//"Uncaught RangeError: Maximum call stack size exceeded"
var cylicGraph = {
    "left"  : { "left" : null, "right" : null, "data" : 3 },
    "data"  : 8
};
cylicGraph["right"] = cylicGraph;

var newcylicGraph = deepCopyObj(cylicGraph)
newcylicGraph.data = 9;
console.log(JSON.stringify(cylicGraph))
console.log(JSON.stringify(newcylicGraph))

这个clone的方法不能处理所有的JS对象，但已经能满足大部分的需求了，只要你不把所有的工作的丢给它就可以了。

作者：mervynYang
链接：http://www.jianshu.com/p/37f39715c2f8
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。