JS 深拷贝

先举例说下深拷贝和浅拷贝的区别：

var a = { name: 'bob' };
var b = a; // b: { name: 'bob' };
a.name = 'tom';
console.log(b); //b: { name: 'tom' };

可以发现直接拷贝，当原对象 a 改变时， b 也发生了改变；这种就是浅拷贝，因为虽然是拷贝成功但是 a 和 b 所指向的内存地址是相同的，所以a改变时，b也会发生改变。

那么如何拷贝才能使b不受a的影响呢；也就是深拷贝呢？

             function typeOf(obj) {
                const toString = Object.prototype.toString;
                const map = {
                    '[object Boolean]'  : 'boolean',
                    '[object Number]'   : 'number',
                    '[object String]'   : 'string',
                    '[object Function]' : 'function',
                    '[object Array]'    : 'array',
                    '[object Date]'     : 'date',
                    '[object RegExp]'   : 'regExp',
                    '[object Undefined]': 'undefined',
                    '[object Null]'     : 'null',
                    '[object Object]'   : 'object'
                };
                return map[toString.call(obj)];
            }
            function deepCopy(data) {
                const t = typeOf(data);
                let o;
            
                if (t === 'array') {
                    o = [];
                } else if ( t === 'object') {
                    o = {};
                } else {
                    return data;
                }
            
                if (t === 'array') {
                    for (let i = 0; i < data.length; i++) {
                        o.push(deepCopy(data[i]));
                    }
                } else if ( t === 'object') {
                    for (let i in data) {
                        o[i] = deepCopy(data[i]);
                    }
                }
                return o;
            }                

解释： 通过typeOf方法我们可以准确区别数组和对象，然后直接调用deepCopy就可以深拷贝成功。

第二种深拷贝方法

function deepcopy(source) {
  if (!source || (!(source instanceof Array) && !(source instanceof Object))) {
    return source
  }
  const sourceCopy = source instanceof Array ? [] : {}
  for (const item in source) {
    sourceCopy[item] = typeof source[item] === 'object' ? deepcopy(source[item]) : source[item]
  }
  return sourceCopy
}