1.构造函数

任何一个函数只要被new使用了，就是构造函数。
构造函数用来存放每一个实例自己具有的属性和方法。

<script>
    function Person(name,age){
        //每一个实例有自己的名字和年龄，而不是所有的实例共享同一个名字和年龄
        this.name=name;
        this.age=age;
    }
    let p=new Person('abc',20);
    console.log(p);
</script>

可以看到上面创建的P实例对象，具有__proto__属性，指向的对象就是原型对象。同时构造函数Person中prototype属性指向的也是该原型对象，完全全等。

2.原型对象原型链

• 任何一个构造函数在创建的时候，都有一个prototype属性，该属性指向原型对象。
• 任何一个引用对象(数组、对象、函数)，都有一个__proto__属性，该属性也指向原型对象。
• 原型对象中有constructor属性，指向构造函数；有__proto__属性指向父类的原型对象。

原型对象中有一个constructor属性，指向构造函数Person(name,age)。
原型对象也有__proto__，指向其父类的原型对象，这里是指向Object的原型对象。

原型对象用来存放所有实例共享的属性和方法。

<script>
    function Person(name,age){
        //每一个实例有自己的名字和年龄，而不是所有的实例共享同一个名字和年龄
        this.name=name;
        this.age=age;
    }
   //在原型对象中创建共享的方法
    Person.prototype.getName=function(){
      return this.name;
    };

    let p=new Person('abc',20);
    //当在实例中找不到调用的属性或方法时，就会沿着__proto__属性指向的原型对象一层层的向上查找。（原型链）
    //这里调用的是原型对象中的方法
    console.log('name:'+p.getName());
    console.log(p);

    //在p实例对象的__proto__的__proto__中查找，
    //也就是Object构造函数的prototype指向的原型对象，
    //这个Object.prototype.__proto__===null。避免死循环
    p.toString();
</script>

3.instanceof

用于判断引用类型的实例是属于哪个构造函数的方法。

原理：

• 判断实例的__proto__指向的原型对象(隐试原型)与构造函数的prototype属性所指向的原型对象（显式原型）是否是同一个。

  
  

• 子类型的实例instanceof父类型的构造函数，也会返回true

  
  
• 要更加详细的识别是子类型的实例

实例对象.__proto__.constructor===构造函数

4.继承的实现方式

1.使用构造函数实现继承

<script>
    /*1.使用构造函数实现继承*/
    function Father(name,age){
        this.name=name;
        this.age=age;
    }
    //父类原型对象中的方法
    Father.prototype.getName=function(){
      console.log(this.name);
    };

    //父类原型对象中的方法
    Father.prototype.getAge=function(){
        console.log(this.age);
    };

    function Son(name,age){
        Father.call(this,name,age);
    }

    let son =new Son('abc',13);
    console.log(son);

</script>

缺点：
只能继承父类实例的属性和方法，不能继承父类原型对象中的属性和方法。

2.使用原型链继承

<script>
    /*1.使用构造函数实现继承*/
    function Father(name,age){
        this.name=name;
        this.age=age;
    }
    //父类原型对象中的方法
    Father.prototype.getName=function(){
      console.log(this.name);
    };

    //父类原型对象中的方法
    Father.prototype.getAge=function(){
        console.log(this.age);
    };

    function Son(name,age){
        //Father.call(this,name,age);
    }

    //使用原型链实现继承，将子类构造函数的prototype指向的原型对象赋值
    //为父类的一个实例。
    Son.prototype=new Father();


</script>

缺点：父类所有的属性和方法，在子类中都成了原型对象中的属性和方法。

3.组合式继承
使用call方法来继承构造函数中的属性和方法，
使用原型链来继承原型对象的属性和方法。

<script>
    /*1.使用构造函数实现继承*/
    function Father(name,age){
        this.name=name;
        this.age=age;
    }
    //父类原型对象中的方法
    Father.prototype.getName=function(){
      console.log(this.name);
    };

    //父类原型对象中的方法
    Father.prototype.getAge=function(){
        console.log(this.age);
    };

    function Son(name,age){
        Father.call(this,name,age);
    }

    //使用原型链实现继承，将子类构造函数的prototype指向的原型对象赋值
    //为父类的一个实例。
    Son.prototype=new Father();


</script>

缺点：子类的原型对象中有父类构造函数中的属性和方法，同时子类的实例中也有父类构造函数中的属性和方法，继承了两次。

4.改进的组合继承1

<script>
    /*1.使用构造函数实现继承*/
    function Father(name,age){
        this.name=name;
        this.age=age;
    }
    //父类原型对象中的方法
    Father.prototype.getName=function(){
      console.log(this.name);
    };

    //父类原型对象中的方法
    Father.prototype.getAge=function(){
        console.log(this.age);
    };

    function Son(name,age){
        Father.call(this,name,age);
    }

    //使用原型链实现继承，将子类构造函数的prototype指向的原型对象赋值
    //为父类构造函数的原型对象。
    Son.prototype=Father.prototype;


</script>

缺点：用了父类的原型对象，父类原型对象中的constructor指向父类的构造函数。

5.改进的组合继承2

<script>
    /*1.使用构造函数实现继承*/
    function Father(name,age){
        this.name=name;
        this.age=age;
    }
    //父类原型对象中的方法
    Father.prototype.getName=function(){
      console.log(this.name);
    };

    //父类原型对象中的方法
    Father.prototype.getAge=function(){
        console.log(this.age);
    };

    function Son(name,age){
        Father.call(this,name,age);
    }

    //使用原型链实现继承，将子类构造函数的prototype指向的原型对象赋值
    //为父类构造函数的原型对象的副本。
    Son.prototype=Object.create(Father.prototype);
    //设置constructor为父类的构造函数
    Son.prototype.constructor=Son;


</script>

5.new关键字的执行过程

<script>
    function Person(name,age) {
        this.name=name;
        this.age=age;
    }

    function mynew(fn,name,age){
        //1.创建一个继承自构造函数原型对象的空对象
        let o=Object.create(fn.prototype);
        //2.调用构造函数为该对象赋值
        let k=fn.call(o,name,age);
        //3.如果构造函数中返回的k是对象,则返回k
        if(typeof k==='object')
            return k;
        //4.如果不是返回o
        else
            return o;

    }

    let person=mynew(Person,'abc',13);
    console.log(person);

</script>