对象的深浅拷贝

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。
但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象

默认浅拷贝

一、浅拷贝

拷贝了对象的存放地址，只是指向相同而已 （只解决了第一层，对象中还有对象就不适用了）

浅拷贝只是拷贝基本类型的数据，如果父对象的属性等于数组或另一个对象，那么实际上，子对象获得的只是一个内存地址，因此存在父对象被篡改的可能，浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存

二、深拷贝

完全复制了一个独立的个体

深拷贝就是能够实现真正意义上的数组和对象的拷贝。递归调用"浅拷贝"。（深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象）

三、ES5 继承

第一种继承 引用值类型，内存地址相同，继承原型

        son.prototype = Father.prototype;

第二种继承 继承原型 和 私有属性

        Son.prototype = new Father({});

第三种继承

        function middle() {}; // 中间商
        middle.prototype = Father.prototype; // 继承原型
        Son.prototype = new middle(); // 过滤私有属性

第四种继承 for in 遍历 只拷贝一层 不会遍历原型链（浅拷贝）

        for (var key in Father.prototype) {
            Son.prototype[key] = Father.prototype[key];
        }

第五种 这种拷贝方法 不支持拷贝函数

把先对象转化为字符串（值类型，字符串格式对象），再转化为JSON 格式对象，

原理： 用 JSON.stringify 将对象转成 JSON 字符串，再用JSON.parse() 把字符串解析成对象，一去一来，新的对象产生了，而且对象会开辟新的栈，实现深拷贝。

这种方法虽然可以实现数组或对象深拷贝，但不能处理函数。

这是因为 JSON.stringify() 方法是将一个JavaScript 值(对象或者数组)转换为一个 JSON 字符串，不能接受函数。

        JSon.parse( JSON.stringfy(obj) )

image.png

四、ES6继承

子类 extends 基类（父类）
constructor内部必须调用 super()方法，继承私有属性，必须传参
如果不调用，报语法错误
constructor 之外默认写原型扩展方法，默认继承父类原型方法

        class Person {
            constructor (data) {
                this.name = data.name;
                this.age = data.age;
            }

            add(){console.log(this.name);}
            sub(){console.log(this.age);}
        }

        class Son extends Person{
            constructor (data) {
                super(data),
                this.x = data.x
            }

            del(){
                console.log(this.name)
            }
        }

        const p1 = new Person({
            "name" : '帅逼',
            "age" : 18
        });

        const p2 = new Son({
            "name" : '大帅逼',
            "age" : 213456,
            "x" : 465
        });

        console.log(p1.name) // 帅逼
        console.log(p1.age) // 18
        console.log(p1.x) // undefined
        console.log(p2.name) // 大帅逼
        console.log(p2.age) // 213456
        console.log(p2.x) // 465

ES5 深浅拷贝

        var obj1 = {
            a : 1,
            b : [1, 2, 3, {
                a : 1,
                b : 2
            }],
            c : undefined,
            d : null
        };

        // obj 为要拷贝的对象 deep 为开启深浅拷贝
        function copy(obj1, deep) {
            var obj2 = {}

            // 判断对象是否是数组   Array.isArray(obj) 有兼容问题，所以排除 
            if (obj1 instanceof Array) {
                obj2 = [];
            }

            /*
                判断每一个值是否是引用值对象
                判断当前是 深拷贝 还是 浅拷贝
                浅拷贝直接赋值
                深拷贝继续拷贝下去
                
            */ 
            for (var key in obj1) {
                var value = obj1[key]; // 取出每一个值
                obj2[key] = (!!deep && typeof value === 'object' && value !== null) ? copy(value, deep) : value;
            }

            return obj2;
        }
        const obj2 = copy(obj1,true) // 不传递deep参数的时候默认就是浅拷贝
        obj2.b.push('x')
        console.log(obj1)
        console.log(obj2)