目录
4. 组合继承方式 优化1：（直接改变原型__proto__的指向）
参考链接
https://github.com/mqyqingfeng/Blog
https://github.com/huyaocode/webKnowledge
《JavaScript高级程序设计》
原型与原型链
首先要明确constructor, prototype, __proto__这三个属性到底指向什么，直接上图
prototype
每个函数都有一个 prototype 属性，比如：
function Person() {
}
// 虽然写在注释里，但是你要注意：
// prototype是函数才会有的属性
Person.prototype.name = 'Kevin';
var person1 = new Person();
var person2 = new Person();
console.log(person1.name) // Kevin
console.log(person2.name) // Kevin那这个函数的 prototype 属性到底指向的是什么呢？是这个函数的原型吗？
其实，函数的 prototype 属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型，也就是这个例子中的 person1 和 person2 的原型。
那什么是原型呢？你可以这样理解：每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型"继承"属性。
让我们用一张图表示构造函数和实例原型之间的关系：
那么我们该怎么表示实例与实例原型，也就是 person 和 Person.prototype 之间的关系呢，这时候我们就要讲到第二个属性：
__proto__
这是每一个JavaScript对象(除了 null )都具有的一个属性，叫__proto__，这个属性会指向该对象的原型。
为了证明这一点,我们可以在火狐或者谷歌中输入：
function Person() {
}
var person = new Person();
console.log(person.__proto__ === Person.prototype); // true于是我们更新下关系图：
既然实例对象和构造函数都可以指向原型，那么原型是否有属性指向构造函数或者实例呢？
constructor
指向实例倒是没有，因为一个构造函数可以生成多个实例，但是原型指向构造函数倒是有的，这就要讲到第三个属性：constructor，每个原型都有一个 constructor 属性指向关联的构造函数。
为了验证这一点，我们可以尝试：
function Person() {
}
console.log(Person === Person.prototype.constructor); // true所以再更新下关系图：
综上我们已经得出：
function Person() {
}
var person = new Person();
console.log(person.__proto__ == Person.prototype) // true
console.log(Person.prototype.constructor == Person) // true
// 顺便学习一个ES5的方法,可以获得对象的原型
console.log(Object.getPrototypeOf(person) === Person.prototype) // true了解了构造函数、实例原型、和实例之间的关系，接下来我们讲讲实例和原型的关系：
实例与原型
当读取实例的属性时，如果找不到，就会查找与对象关联的原型中的属性，如果还查不到，就去找原型的原型，一直找到最顶层为止。
举个例子：
function Person() {
}
Person.prototype.name = 'Kevin';
var person = new Person();
person.name = 'Daisy';
console.log(person.name) // Daisy
delete person.name;
console.log(person.name) // Kevin在这个例子中，我们给实例对象 person 添加了 name 属性，当我们打印 person.name 的时候，结果自然为 Daisy。
但是当我们删除了 person 的 name 属性时，读取 person.name，从 person 对象中找不到 name 属性就会从 person 的原型也就是 person.__proto__ ，也就是 Person.prototype中查找，幸运的是我们找到了 name 属性，结果为 Kevin。
但是万一还没有找到呢？原型的原型又是什么呢
原型的原型
在前面，我们已经讲了原型也是一个对象，既然是对象，我们就可以用最原始的方式创建它，那就是：
var obj = new Object();
obj.name = 'Kevin'
console.log(obj.name) // Kevin其实原型对象就是通过 Object 构造函数生成的，结合之前所讲，实例的 __proto__ 指向构造函数的 prototype ，所以我们再更新下关系图：
原型链
那 Object.prototype 的原型呢？
null，我们可以打印：console.log(Object.prototype.__proto__ === null) // true
然而 null 究竟代表了什么呢？
引用阮一峰老师的 《undefined与null的区别》 就是：
null 表示“没有对象”，即该处不应该有值。
所以 Object.prototype.__proto__ 的值为 null 跟 Object.prototype 没有原型，其实表达了一个意思。
所以查找属性的时候查到 Object.prototype 就可以停止查找了。
（红宝书：从逻辑角度来看，null值表示一个空对象指针）
最后一张关系图也可以更新为：
图中由相互关联的原型组成的链状结构就是原型链，也就是蓝色的这条线。
补充
constructor
首先是 constructor 属性，我们看个例子：
function Person() {
}
var person = new Person();
console.log(person.constructor === Person); // true当获取 person.constructor 时，其实 person 中并没有 constructor 属性,当不能读取到constructor 属性时，会从 person 的原型也就是 Person.prototype 中读取，正好原型中有该属性，所以：
person.constructor === Person.prototype.constructor可以这么验证
function Person() {
}
let person = new Person()
console.log(person.hasOwnProperty('constructor')) // false
console.log('constructor' in person) // true
// hasOwnProperty方法当属性为实例属性而非原型属性时返回true
// in 操作符会在通过对象能够访问给定属性时返回 true，无论该属性存在于实例中还是原型中__proto__
其次是 __proto__ ，绝大部分浏览器都支持这个非标准的方法访问原型，然而它并不存在于 Person.prototype 中，实际上，它是来自于 Object.prototype ，与其说是一个属性，不如说是一个 getter/setter，当使用 obj.__proto__ 时，可以理解成返回了 Object.getPrototypeOf(obj)。
对继承的解释
前面我们讲到“每一个对象都会从原型‘继承’属性”，实际上，继承是一个十分具有迷惑性的说法，引用《你不知道的JavaScript》中的话，就是：
继承意味着复制操作，然而 JavaScript 默认并不会复制对象的属性，相反，JavaScript 只是在两个对象之间创建一个关联，这样，一个对象就可以通过委托访问另一个对象的属性和函数，所以与其叫继承，委托的说法反而更准确些。
总结
1.每个函数都有一个 prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法，如果使用这个函数生成了实例，那么称这个对象为所有实例的原型。
2.对象都拥有__proto__和constructor属性，因为函数也是一种对象，所以函数也有这两个属性。__proto__用于实现原型链，当访问一个对象的属性时，如果该对象内部不存在这个属性，就通过原型链找直到找到或者到终点null；实例和原型的constructor属性指向对应的构造函数（实例本身没有该属性，但可以通过原型找到）
继承
虽然红宝书中有说，但是那个命名真心不理解啊......
1.借用构造函数法
在构造函数中 使用Parent.call(this)的方法继承父类属性。
原理： 将子类的this使用父类的构造函数跑一遍
缺点： Parent原型链上的属性和方法并不会被子类继承（子类连接不到父类）
function Parent() {
this.name = 'parent'
}
Parent.prototype.sayHello = function() {
console.log('say Hello')
}
function Child() {
Parent.call(this); //函数名.call 调用这个函数但是更改其this
this.type = 'child'
}
let p1 = new Parent()
let c1 = new Child()
p1.sayHello() // 'say Hello;
c1.sayHello() // error c1.sayHello is not a function
2.原型链实现继承
原理：把子类的prototype（原型对象）直接设置为父类的实例
缺点：因为子类只进行一次原型更改，所以子类的所有实例保存的是同一个父类的值。 当子类对象上进行值修改时，如果是修改的原始类型的值，那么会在实例上新建这样一个值； 但如果是引用类型的话，他就会去修改子类上唯一一个父类实例里面的这个引用类型，这会影响所有子类实例（一句话：子类修改原型上的引用类型会影响父类）
function Parent() {
this.name = 'parent'
this.arr = [1,2,3]
}
function Child() {
this.type = 'child'
}
Child.prototype = new Parent(); //拥有了这个Parent实例上的属性和方法
var c1 = new Child();
var c2 = new Child();
c1.__proto__ === c2.__proto__ // true
console.log(Child.prototype.__proto__ === Parent.prototype) // true
这里得理解构造函数new时到底发生了什么
(1) 创建一个新对象；
(2) 将构造函数的作用域赋给新对象（因此 this 就指向了这个新对象）；
(3) 执行构造函数中的代码（为这个新对象添加属性）；
(4) 返回新对象。
其实还将这个空对象的__proto__属性指向了构造函数的prototype属性指向的对象（可能在（2）吧）
3.组合继承方式（上面两个的配合）
组合构造函数中使用call继承和原型链继承。
原理： 子类构造函数中使用Parent.call(this)的方式可以继承写在父类构造函数中this上绑定的各属性和方法； 使用Child.prototype = new Parent()的方式可以继承挂在在父类原型上的各属性和方法
缺点： 父类构造函数在子类构造函数中执行了一次，在子类绑定原型时又执行了一次
function Parent() {
this.name = 'parent'
this.arr = [1,2,3]
}
function Child() {
Parent.call(this); //继承Parent构造函数上的属性和方法
this.type = 'child'
}
Child.prototype = new Parent(); //继承Parent的父类原型上的属性和方法
4. 组合继承方式 优化1：（直接改变原型__proto__的指向）
因为这时父类构造函数的方法已经被执行过了，只需要关心原型链上的属性和方法了
Child.prototype = Parent.prototype;缺点：
因为原型上有一个属性为constructor，此时直接使用父类的prototype的话那么会导致实例的constructor为Parent，即不能区分这个实例对象是Child的实例还是父类的实例对象。
子类不可直接在prototype上添加属性和方法，因为会影响父类的原型
5.组合继承方式 优化2 - 添加中间对象【最通用版本】：
function Parent() {
this.name = 'parent'
this.arr = [1,2,3]
}
function Child() {
Parent.call(this);
this.type = 'child'
}
Child.prototype = Object.create(Parent.prototype); //提供__proto__
Child.prototype.constrctor = Child;
Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__
6.ES6的继承（待补充）
小结：
简单来说，我们希望子类继承父类原型上的方法和属性，且子类操作其原型上的方法和属性时不会影响父类，这就是继承的最终目的（吧）。
