总结原型、原型链、原型继承

原型

原型是一个对象，其他对象可以通过它实现属性继承。

对象中都会包含一些预定义的属性。其中每个函数对象都有一个prototype 属性，这个属性指向函数的原型对象。

原型链

  JavaScript 只有一种结构：对象。每个实例对象（object ）都有一个私有属性（称之为__proto__）指向它的原型对象（prototype）。该原型对象也有一个自己的原型对象(__proto__) ，层层向上直到一个对象的原型对象为 null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。

   图片转载：https://www.cnblogs.com/shuiyi/p/5305435.html

 属性搜索原则：
     1.当访问一个对象的成员的时候，会现在自身找有没有,如果找到直接使用。
     2.如果没有找到，则去原型链指向的对象的构造函数的prototype中找，找到直接使用，没找到就返回undifined或报错。

 

原型继承方式

1. 原型链继承

2，构造函数继承（对象冒充继承）

3，组合继承（原型链继承+构造函数继承）

4. 寄生组合式继承

一、原型链继承

核心： 将父类的实例作为子类的原型

function Show(){

  this.name="run";

}

function Run(){

  this.age="20"; //Run继承了Show,通过原型，形成链条

}

Run.prototype=new Show();

var show=new Run();

alert(show.name)//结果：run

特点：

1. 非常纯粹的继承关系，实例是子类的实例，也是父类的实例
2. 父类新增原型方法/原型属性，子类都能访问到
3. 简单，易于实现

缺点：

1. 要想为子类新增属性和方法，必须要在new Show()这样的语句之后执行，不能放到构造器中
2. 无法实现多继承
3. 来自原型对象的所有属性被所有实例共享
4. 创建子类实例时，无法向父类构造函数传参

二、构造函数继承（对象冒充继承）

核心：使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）

为了解决引用共享和超类型无法传参的问题，我们采用一种叫借用构造函数的技术，或

者成为对象冒充(伪造对象、经典继承)的技术来解决这两种问题 

function Box(age){

  this.name=['Lee','Jack','Hello']

  this.age=age;

}

function Desk(age){

  Box.call(this,age); //对象冒充，给超类型传参

}

var desk = new Desk(200);

alert(desk.age);//200

alert(desk.name);//['Lee','Jack','Hello']

desk.name.push('AAA'); //添加的新数据，只给 desk

alert(desk.name)//['Lee','Jack','Hello','AAA']

特点：

1. 解决了1中，子类实例共享父类引用属性的问题
2. 创建子类实例时，可以向父类传递参数
3. 可以实现多继承（call多个父类对象）

缺点：

1. 实例并不是父类的实例，只是子类的实例
2. 只能继承父类的实例属性和方法，不能继承原型属性/方法
3. 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

三、组合继承（原型链继承+构造函数继承）

核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

 

借用构造函数虽然解决了刚才两种问题， 但没有原型， 复用则无从谈起。 所以， 我们需

要原型链+借用构造函数的模式，这种模式成为组合继承（组合继承无论在什么情况下,都会调用两次父类构造函数）。

function Box(age) {

this.name = ['Lee', 'Jack', 'Hello']

this.age = age;

}

Box.prototype.run = function () {

return this.name + this.age;

};

function Desk(age) {

Box.call(this, age); //对象冒充（第二次调用）

}

Desk.prototype = new Box(); //原型链继承（第一次调用）

var desk = new Desk(100);

alert(desk.run());

特点：

1. 可以继承实例属性/方法，也可以继承原型属性/方法
2. 既是子类的实例，也是父类的实例
3. 不存在引用属性共享问题
4. 可传参
5. 函数可复用

缺点：

1. 调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）

四、寄生组合式继承

核心：通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点

组合式继承就会有两次调用的情况，寄生组合式继承解决了两次调用的问题

基本模型如下：

function object(o) {     

 function F() {}     

 F.prototype = o;     

 return new F();

}

function inheritPrototype(subType, superType) {   

   var prototype = object(superType.prototype);  //返回父类的原型指针   

  prototype.constructor = subType;              //将父类的原型指针构造指针指向子类     

  subType.prototype = prototype;                //将子类原型指针指向父类的原型

}

function SuperType(name) {

    this.name = name;

    this.colors = ["red","blue","green"];

}

SuperType.prototype.sayname = function(){

    console.log(this.name);

};

function SubType(name,age) {

    SuperType.call(this,name);

    this.age = age;

}

inheritPrototype(SubType,SuperType);

SubType.prototype.sayAge = function() {

    console.log(this.age);

}

var instances = new SubType("xue",30);

instances.sayname();

特点：

1. 堪称完美

缺点：

1. 实现较为复杂

以上内容是网上总结整理的资料。如觉得抄袭请联系我删除文章