Prototype inheritance

Give Way P2 Inherit P1, The following will be P1 Attribute to P2, This method is not recommended

<script>
    function P1() {
      this.name = arguments[0];
      this.age = arguments[1];
    }
    
    P1.prototype.sayName = function () {
      alert(this.name);
    };
    
    //  By copying , To inherit P1
    function P2() {
      this.name = arguments[0];
      this.age = arguments[1];   
    }
  </script>

    function P2() {
      //  obj2 = this
      this.name = arguments[0];
      this.age = arguments[1];
    }
    //   In the instance P2 when , Yes .
	//   Then these attributes are also attached to the object of the instance 
    new P2();

Then we just need to P1 You can mount the properties in to the object of the instance

   
function P1(opt) {
      this.name = opt.name;
      this.age = opt.age;
    }

    P1.prototype.sayName = function () {
      alert(this.name);
    };


    function P2(opt) {
      //  Inherit all of the base class 
      P1.call(this, opt)
      //  Expands itself 
      this.sex = opt.sex;
    }

    //  Scheme 1 ：  Because the prototype is an object , Reference type data . If you will P1 The archetype of is given to P2, Then when expanding P2 The prototype is , It will also modify P1
    /*P2.prototype = P1.prototype;*/

    //  Option two ：  send P1 The object of the instance obj1 Mount to  P2 On the prototype of 
    P2.prototype = new P1({});

    //  At this time P2 On the prototype , It won't affect P1 The prototype of the 
    P2.prototype.add = function () {
      alert(this.name)
    }

    const o1 = new P1({
      name: 'Lee',
      age: 18
    });

    const o2 = new P2({
      name: ' Liang what duck ',
      age: 18,
      sex: 'girl'
    });

    o1.sayName();
    o2.add();

When the output o2
This is because when P2.prototype = new P1({});, hold P1 The private property of extends to P2 The prototype of
But logically, it does not affect , Because the private attribute to be inherited

To remove these values is undefined Properties of , Available scheme 3 , With the help of a useless function

//  Option three ：
    function c() {} // c Class has no private properties , It's empty. 
    c.prototype = P1.prototype
    P2.prototype = new c();

Output o2

There is another scheme that has nothing to do with the previous three schemes 4
The main reason for the elimination of scheme 1 is that they point to the same memory address , To modify a , Another prototype is also modified

//  Option four ： It has nothing to do with the previous three schemes 
    for(var key in P1.prototype) {
      P2.prototype[key] = P1.prototype[key];
    }

Scheme 4 cannot traverse P1 The prototype of the prototype
Scheme 3 is recommended , Can traverse to