对象深拷贝

        let obj = {
            a: '123456',
            b: 123456,
            c: {
                name: 'haha',
                age: 18,
                sex: null
            },
            arr: [
                { id: 1, title: 2 },
                { id: 2, title: 2 },
                { id: 3, title: 2 },
                { id: 4, title: 2 }
            ]
        };

        function deepClone(origin, target){
            // 目标对象（target）为undefined时置为空对象
            target = target || {};
            for (let key in origin) {
                // 剔除数据源原型上的数据（__proto__上的数据）
                if(origin.hasOwnProperty(key)){
                    if(origin[key] && typeof origin[key] === 'object'){
                        // 开始迭代
                        target[key] = deepClone(origin[key], Array.isArray(origin[key]) ? [] : {});
                    } else {
                        // 原始数据类型(string, number, function)和undefined、null直接赋值
                        target[key] = origin[key];
                    }
                }
            }
            return target;
        }
        let obj1 = deepClone(obj);
        obj1.b = 456789;
        console.log('obj :', obj);
        console.log('obj1 :', obj1);

console

进化版深拷贝：过滤掉对象深拷贝中不想要的值
ES6参数预赋值

        function Parent (name){
            this.name = name;
        }

        const obj = {
            a: 1,
            b: '哈哈哈',
            c: null,
            d: undefined,
            e: [{ a: 1, b: '哈哈哈' }, { a: 1, b: '哈哈哈' }, { a: 1, b: '哈哈哈' }],
            f: { a: 1, b: '哈哈哈', c: [{ a: 1, b: '哈哈哈' }, { a: null, b: '1' }, { a: undefined, b: '1' }] },
            g: function(){},
            h: new Date(),
            i: Parent,
            j: new Parent('小明')
        };
        // 深拷贝代码
        function deepClone(origin = {}, filter = [], target = {}){
            for(let key in origin){
                if(origin.hasOwnProperty(key)){
                    if(origin[key] && typeof origin[key] === 'object'){
                        target[key] = deepClone(origin[key], filter, Array.isArray(origin[key]) ? [] : {});
                    } else {
                        if(filter.length){
                            // 判断其值是否在当前过滤数组内，不存在则开始赋值
                            if(!filter.includes(origin[key])){
                                target[key] = origin[key];
                            }
                        } else {
                            target[key] = origin[key];
                        }
                    }
                }
            }
            return target;
        }
        // 结果
       let obj1 = deepClone(obj, [null, undefined]);
        obj1.f.a = 2;
        obj1.f.c[0].a = 'null';
        obj1.g = new Date();
        obj1.y = '拉拉拉拉拉拉啊啦啦';
        console.log(obj);
        console.log(obj1);

1592645588(1).jpg

深拷贝合并

        function deepCloneAssign(origin = {}, ...args){
            for (let i in args) {
                for (let key in args[i]) {
                    if(args[i].hasOwnProperty(key)){
                        origin[key] = args[i][key] && typeof args[i][key] === 'object' ? deepCloneAssign(Array.isArray(args[i][key]) ? [] : {}, origin[key], args[i][key]) : args[i][key];
                    }
                }
            }
            return origin;
        }
        // 调用 PS：首位参数必须为空对象，首位参数值已有属性会被后面的参数值属性覆盖
        const obj3 = deepCloneAssign({}, obj, obj1, obj2, ...);
        // 如果想单独使用数组深合并，注释掉 if判断 并且首位参数必须为空数组。建议复杂类型数组使用
        const arr4 = deepCloneAssign([], arr1, arr2, arr3, ...);