谈谈我对深拷贝和浅拷贝的理解

浅拷贝只拷贝一层，深拷贝是层层递归拷贝。

详细点讲，就是在进行浅拷贝的时候，被拷贝的对象（称作P对象）的子属性A也是一个对象，那么因为浅拷贝只拷贝了一层，所以拷贝后返回的新对象（称作S对象）的子属性A其实和P对象的子属性A仍然联系在一起的，如果对P对象的子属性A重新赋值，不会影响S对象的子属性A，但是当只是给P对象的子属性A的子属性赋值的时候，那么S属性的子属性A的子属性的值也会被改变。而因为深拷贝进行了递归，所以就不会存在这个问题。

这个解释。。。。有点绕啊？？？？那么请看栗子

举个栗子 (浅拷贝)

    function shallowCopy(src) {
        var dst = {};
        for (var prop in src) {
            if (src.hasOwnProperty(prop)) {
                dst[prop] = src[prop];
            }
        }
        return dst;
    }

    var a = {
        key1: "111",
        key2: ['222', '333']
    }
    a.key3 = ['444', '555'];
    var b = shallowCopy(a);
    b.key2 = ['666', '777'];
    a.key3[0] = '888'
    console.log(a.key2) // ['222', '333']
    console.log(b.key2) // ['666', '777']
    console.log(a.key3) // ['888', '555']
    console.log(b.key3) // ['888', '555']
复制代码

下面关于深拷贝的方法是从 司徒正美 的avalon里面找到的（出处）

再举个栗子（深拷贝）

    function deepCopy() {
        var options, name, src, copy, copyIsArray, clone,
            target = arguments[0] || {},
            i = 1,
            length = arguments.length,
            deep = false
        var isPlainObject = function (obj) {
            return Object.prototype.toString.call(obj) === "[object Object]" && Object.getPrototypeOf(obj) === Object.prototype
        }
        if (typeof target === "boolean") {
            deep = target
            target = arguments[1] || {}
            i++
        }
        if (typeof target !== "object" && !this.isFunction(target)) {
            target = {}
        }
        if (i === length) {
            target = this
            i--;
        }

        for (; i < length; i++) {
            if ((options = arguments[i]) != null) {
                for (name in options) {
                    src = target[name]
                    copy = options[name]
                    if (target === copy) {
                        continue
                    }
                    if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
                        if (copyIsArray) {
                            copyIsArray = false
                            clone = src && Array.isArray(src) ? src : []
                        } else {
                            clone = src && isPlainObject(src) ? src : {}
                        }
                        target[name] = arguments.callee(deep, clone, copy);
                    } else if (copy !== void 0) {
                        target[name] = copy
                    }
                }
            }
        }
        return target
    }

    var a = {
        key1: "111",
        key2: ['222', '333']
    }
    a.key3 = ['444', '555'];
    var b = deepCopy(true, {}, a);
    b.key2 = ['666', '777'];
    a.key3[0] = '888'
    console.log(a.key2) // ['222', '333']
    console.log(b.key2) // ['666', '777']
    console.log(a.key3) // ['888', '555']
    console.log(b.key3) // ['444', '555']

复制代码

现在懂了没？你懂没懂没关系，反正我懂了，哈哈。