原型链
什么是原型？
function Person(){
}
let p = new Person()
实例对象拥有__proto__
函数拥有Person.prototype,Person.prototype就是原型，它是一个对象，我们也称它为原型对象。
什么是原型链
原型与原型层层相链接的过程即为原型链。
Object.prototype.__proto__ // null
Function.prototype.__proto__ === Object.prototype // true
Function.__proto__ === Function.prototype // true
image
function Person(params) {
}
Person.prototype.n = 1
Person.prototype.add = function () {
this.n++
}
let p1 = new Person()
let p2 = new Person()
p1.add()
p2.add()
console.log(Person.prototype.n) // 1
p1.add()执行时，add中this的指向为p1这个对象实例，当p1的属性找不到n时，通过原型链向上查找，找到n=1,然后给当前对象p1进行赋值
原型继承
原型模式
function Person() {
this.name = '小王'
this.color = ['red', 'black']
this.getName = function () {
console.log(this.name);
}
}
function Man() {
this.name = '小黄'
}
Man.prototype = new Person()
const man = new Man()
const man2 = new Man()
man.color.push('green')
console.log(man.color); // ['red', 'black', 'green']
console.log(man2.color); // ['red', 'black', 'green']
两个问题：
- 原型中的引用值会在多个实例间共享
- 子类型在实例化时不能给夫类型的构造函数传参
盗用构造函数（对象伪装 或 经典继承）
function Person() {
this.name = '小王'
this.color = ['red', 'black']
this.getName = function () {
console.log(this.name);
}
}
function Man() {
Person.call(this)
this.name = '小黄'
}
const man = new Man()
const man2 = new Man()
man.color.push('green')
console.log(man.color); // ['red', 'black', 'green']
console.log(man2.color); // ['red', 'black']
通过使用call()（或apply()）方法，Person的构造函数在Man的实例创建的上下文中执行了。相当于新的Man对象上运行了Person函数中的所有初始化代码,结果就是每个实例都会有自己的colors属性。
优点
- 能够在子类构造函数中像父类构造函数传参
问题
- 必须在构造函数中定义方法，因此函数不能重用
- 子类也不能访问父类原型上定义的方法，因此所有类型只能使用构造函数模式
组合继承（伪经典继承）
综合原型链和盗用构造函数，结合两者的优点。
思路是使用原型链继承原型上的属性和方法，通过盗用构造函数继承实例属性
function Person() {
this.name = '小王'
this.color = ['red', 'black']
this.getName = function () {
console.log(this.name);
}
}
function Man() {
// 继承构造函数实例的属性
Person.call(this)
this.name = '小黄'
}
// 继承原型的属性和方法
Man.prototype = new Person()
const man = new Man()
const man2 = new Man()
man.color.push('green')
console.log(man.color); // ['red', 'black', 'green']
console.log(man2.color); // ['red', 'black']
组合继承弥补了原型链和盗用构造函数的不足，是JavaScript中使用最多的继承模式。而且组合继承也保留了instanceof操作符和isPrototypeOf()方法识别合成对象的能力。
原型式继承
function object(o) {
function F() {}
F.prototype = o;
return new F()
}
object会创建一个临时构造函数，将传入的对象赋值给这个构造函数的原型，然后返回这个临时构造函数的实例。
实质上是对传入对象的一次浅复制，所以还存在值引用的问题。
let obj = {
age: 23,
height: 180,
skill: ['java', 'js']
}
const man = object(obj)
const man1 = object(obj)
// es5新增了Object.ceate的方法可替代
const man = Object.create(obj)
const man1 = Object.create(obj)
man.skill.push('c++')
man.skill; // ["java", "js", "c++"]
man1.skill;// ["java", "js", "c++"]
原型式继承非常适合不需要单独创建构造函数，但仍然需要在对象间共享信息的场合。但要记住，属性中包含的引用值始终会在相关对象间共享，跟使用原型模式是一样的。
寄生式继承
寄生式继承背后的思路类似于寄生构造函数和工厂模式：创建一个实现继承的函数，以某种方式增强对象，然后返回这个对象。
function createAnother(original) {
// 通过调用函数创建一个新的对象
let clone = object(original);
// 以某种方式增强这个对象
clone.sayHi = function () {
console.log('Hi');
}
// 返回这个对象
return clone
}
let person = {
name: 'tom',
friends: ['jerry', 'arthur']
}
let anoherPerson = createAnother(person);
anoherPerson.sayHi()
寄生式继承同样适合主要关注对象，而不在乎类型和构造函数的场景。object()函数不是寄生式继承所必需的，任何返回新对象的函数都可以在这里使用。
寄生式组合继承
组合继承其实也存在效率问题。最主要的效率问题就是父类构造函数始终会被调用两次：一次在是创建子类原型时调用，另一次是在子类构造函数中调用。
寄生式组合继承通过盗用构造函数继承属性，但使用混合式原型链继承方法。基本思路是不通过调用父类构造函数给子类原型赋值，而是取得父类原型的一个副本。说到底就是使用寄生式继承来继承父类原型，然后将返回的新对象赋值给子类原型。
function Person() {
this.name = '小王'
this.color = ['red', 'black']
this.getName = function () {
console.log(this.name);
}
}
Person.prototype.code = function () {
console.log('coding');
}
Person.prototype.skill = ['java', 'js']
function Man() {
Person.call(this)
}
function inheritPrototype(man, person) {
const prototype = person.prototype
prototype.constructor = person;
man.prototype = prototype
}
inheritPrototype(Man, Person)
const man = new Man()
寄生式组合继承可以算是引用类型继承的最佳模式。
