异同：

浅复制 (影子克隆): 只复制对象的基本类型, 对象类型, 仍属于原来的引用。
深复制 (深度克隆): 不紧复制对象的基本类, 同时也复制原对象中的对象。就是说完全是新对象产生的。

思路：

遍历所有该对象的属性，
如果该属性是 "object" 则需要特殊处理，
如果这个 object 对象比较特殊，是一个数组，那就创建一个新的数组并深复制数组里的元素
如果这个 object 对象是个非数组对象，那直接再对它递归调用深复制方法即可。
如果不是 "object"，则直接正常复制就行。

注意事项：

直接在 Object.prototype 上实现该方法的好处是，所有对象都会继承该方法。坏处是某些库也会改写 Object 对
象，所以有时会发生冲突。这是需要注意的。

代码：

Object.prototype.deepCopy=function(){
    var obj={};//用于最后返回一个对象，这个对象是深复制的结果
    for(var attr in this){//遍历这个对象的每一个属性
        if(this.hasOwnProperty(attr)){//主要是递归自有属性
            if(typeof (this[attr]==='object')){//如果对象的属性是一个对象，就递归复制它的每一个属性
                if(this[attr]===null){//如果对象为null
                    obj[attr]=null;
                }else if(Object.prototype.toString(this[attr])==='[object Array]'){//如果是个数组
                    obj[attr]=[];
                    for(var i=0;i<this[attr].length;i++){
                        obj[attr].push(this[attr][i].deepCopy());
                    }
                }else{//object
                    obj[attr]=this[attr].deepCopy();
                }
            }else{
                obj[attr]=this[attr];
            }
        }
    }
    return obj;
}

ES6 版本

function deepCopy(obj){
    if(typeof obj === 'object'){
        if(obj === null){
            return null;
        }
        let result = {};
        const keys = Object.keys(obj);
        const length = keys.length;
        for(let i=0;i<length;i+=1){
            const key = keys[i];
            const value = obj[key];
            let data;
            if(Array.isArray(value)){
                data = [];
                for(j=0,len = value.length;j<len;j+=1){
                    const ITem = deepCopy(value[j]);
                    data.push(item);
                }
            }else if(typeof value === 'object'){
                data = deepCopy(value);
            }else{
                data = value;
            }
            result[key] = data;
        }
        return result;
    }else{
        return obj;
    }
}