javascript在创建一个对象的时候，默认会为该对象创建一个prototype的属性，该属性的值是一个对象，即创建对象的原型。

下面我们通过一个例子了解原型的特性：

function Person(){

}

Person.prototype.name="tom"

var person1 = new Person()

console.log(person1.name) //tom

var person2 = new Person()

console.log(person2.name) //tom

上面的例子中，构造函数Person的原型对象有一个自定义属性name

所有的实例共享同一个原型对象,所以打印person1.name和person2.name都是tom

构造函数、原型和实例的关系：

每一个构造函数(函数对象)都有一个prototype属性，指向函数的原型对象；每一个原型对象都有一个constructor属性，指向构造函数；每一个实例都有一个__proto__属性，指向构造函数的原型对象

那么原型对象、prototype对象、实例对象之间的关系图下图所示

上图中prototype对象也是一个实例对象，他也有自己的原型对象，默认原型的构造函数是Object，加上prototype对象关系图如下：

接下来我们来说一下继承

1.原型链继承

function Animal() {

  this.sleep = function() {

    console.log('睡觉')

  }

}

function Person(name) {

  this.name = name

}

Person.prototype = new Animal()

var liming = new Person('liming')

console.log(liming.name)

liming.sleep()

打印结果

2

睡觉

上述例子中，改变了Person构造函数的原型指向，从而实现了继承，让Person的实例liming拥有了sleep的方法。上述例子的图解如下：

缺点：如果Animal实例中有引用类型的变量，这个引用变量被所有实例共享，一个实例更改之后会影响其他实例

如果我们将代码改成

function Animal() {

  this.todoList = ['坐车', '开会', '吃饭', '回家']

  this.sleep = function() {

    console.log('睡觉')

  }

}

function Person(name) {

  this.name = name

}

Person.prototype = new Animal()

var liming = new Person('liming')

console.log(liming.name)

liming.todoList.splice(1, 1)

var tom = new Person('tom')

console.log(tom.todoList)

可以看到liming的代办去掉了开会，tom的代办的开会也没有了。而且没办法给Animal传递实例参数。所以有了构造函数继承

二、构造函数继承

构造函数继承就是在子类的构造函数中执行父类的构造函数，并使用call改变父类的this指向子类，还可以使用call传递参数，实现实例属性，具体代码如下

function Animal(sort) {

  this.sort = sort

  this.todoList = ['坐车', '开会', '吃饭', '回家']

  this.sleep = function() {

    console.log('睡觉')

  }

}

function Person(name, sort) {

  Animal.call(this, sort)

  this.name = name

}

var liming = new Person('liming', 'people')

liming.todoList.splice(1, 1)

console.log('liming的todolist', liming.todoList)

var tom = new Person('tom', 'people')

console.log(tom.sort)

console.log('tom的todolist', tom.todoList)

    结果展示：

上述例子在Person的构造函数中执行了Animal.call(this,sort)  执行力Animal构造函数的代码，并把this，指向当前person实例，所以liming去掉了开会日程，但是并不影响tom的代办列表。

原型关系图解：（这个例子Person的原型指向并没有改变，只是把Person的代码拿来执行了一遍。）

缺点：

这种方法的缺点显而易见，没有实现继承。

三、原型构造函数组合继承

function Animal(sort) {

  this.sort = sort

  this.todoList = ['坐车', '开会', '吃饭', '回家']

  this.sleep = function() {

    console.log('睡觉')

  }

}

Animal.prototype.saySort = function() {

  console.log(this.sort)

}

function Person(name, sort) {

  Animal.call(this, sort)

  this.name = name

}

Person.prototype = new Animal()

var liming = new Person('liming', 'people')

liming.todoList.splice(1, 1)

console.log('liming的todolist', liming.todoList)

var tom = new Person('tom', 'people')

tom.saySort()

顾名思义是前两种方式的结合，在构造函数的基础上使用Person.prototype = new Animal() 改变Person的prototype的指向。从而是可以访问Animal原型上的方法saySort()

关系图解：

可以清晰的看到 liming和tom都有自己的todolist 所以不会去原型上查找todolist属性。

这种方法的缺点：

每个实例都有一份自己的属性，原型上也有一份属性，虽然实例上有就不会去原型上查找，但是这种方法原型上的属性和方法就没有用，有些多余。

4.原型式继承

创建一个名为F的构造函数，把 F的prototype设置为传进来的对象

var person = {

  name: 'tom',

  sayName: function() {

    console.log(this.name)

  }

}

function object(obj) {

  function F() {}

  F.prototype = obj

  return new F()

}

var person1 = object(person)

person1.name = 'jerry'

person1.sayName()

var person2 = object(person)

person2.name = 'jack'

person1.sayName()

打印结果：

结果很明显所有实例共享原型属性

关系图解：

缺点：所有实例共享原型，而且没有自己的实例属性。

5.寄生式继承

在原型式继承的基础上，封装原型式继承

function create(obj, suject) {

  var example = Object(obj)

  example.suject = suject

  return example

}

var person = {

  name: 'tom',

  sayName: function() {

    console.log(this.name)

  }

}

var person1 = create(person, '游泳')

console.log(person1.suject)

person1.name = 'jerry'

var person2 = create(person, '拳击')

console.log(person2.suject)

person2.sayName()

打印结果如下：

显而易见，person1和person2拥有了自己的实例属性，

Object(person) 的作用等同于原型式继承 把person作为构造函数的原型，所有的实例共享person的属性和方法

6.寄生组合式继承

就是把寄生式继承和组合式继承结合起来

function inherite(parent, child) {

  var pro = Object.create(parent.prototype)

  pro.construct = child

  child.prototype = pro

}

function Animal(sort) {

  this.sort = sort

  this.todoList = ['坐车', '开会', '吃饭', '回家']

  this.sleep = function() {

    console.log('睡觉')

  }

}

Animal.prototype.saySort = function() {

  console.log(this.sort)

}

function Person(name, sort) {

  Animal.call(this, sort)

  this.name = name

}

inherite(Animal, Person)

var liming = new Person('liming', 'people')

liming.todoList.splice(1, 1)

console.log('liming的todolist', liming.todoList)

var tom = new Person('tom', 'people')

tom.saySort()

console.log('tom的todolist', tom.todoList)

打印结果

关系图解：

这种方式就避免了再次创建Animal实例，sort todolist  sleep等属性和方法也只存在在实例上，原型上已经没有了。

大多数的继承都采用这种方式。