继承方式

原型对象本身是一个普通对象，而普通对象的构造函数是Object。

除了Object的原型对象（Object.prototype）的proto指向null，其他内置函数对象的原型对象（例如：

Array.prototype）和自定义构造函数的 proto都指向Object.prototype, 因为原型对象本身是普通对象

Object.prototype.__proto__ = null;

Array.prototype.__proto__ = Object.prototype;

Foo.prototype.proto = Object.prototype;

一切对象都是继承自Object对象，Object 对象直接继承根源对象null 一切的函数对象（包括 Object 对象），都是继承自 Function 对象

Object 对象直接继承自 Function 对象 Function对象的proto会指向自己的原型对象，最终还是继承自Object对象

原型&原型链

需要new关键字，成为“构造器constructor或构造函数”。

通过prototype定义的属性，再被多个实例化后，引用地址是同一个。

继承链从祖父——到爷爷——到爸爸——到自己

constructor指向构造函数，每个对象的proto指向创建它的构造函数的prototype，而构造函数的prototype 也有proto指向他的父辈或者是Object，当查找一个对象中不存在的属性时，会去它的proto、proto中的

proto中进行寻找，直到找到或者是null为止 instanceof判断对象的proto和构造函数的prototype是不是同一个地址

Object.setPrototypeOf改变对象的proto

原型(prototype)：一个对象，实现对象的属性继承，简单理解为对象的爹。

prototype可以通过Object.getPrototypeOf() 和 Object.setPrototypeOf() 访问器访问。

当继承的函数被调用时，this 指向的是当前继承的对象，而不是继承的函数所在的原型对象。

不是所有对象都有原型。

继承方式

构造函数会在每一个实例上都创建一遍！

使用原型模式定义的属性和方法由所有实例共享！

原型链

function Parent() { this.name = 'kevin';

}

function Child() {}

Child.prototype = new Parent();

var child1 = new Child();

console.log(child1.getName()) // kevin

缺点

1. 引用类型的属性被所有实例共享
2. 创建Child实例时，不能向Parent传参

借用构造函数(经典继承)

function Parent() { this.names = ['kevin', 'daisy'];

}

function Child() { Parent.call(this);

}

var child1 = new Child();

child1.names.push('yayu');

console.log(child1.names); // ["kevin", "daisy", "yayu"]

var child2 = new Child();

console.log(child2.names); // ["kevin", "daisy"]

1. 避免了引用类型的属性被所有实例共享
2. 可以在 Child 中向 Parent 传参

缺点

方法都在构造函数中定义，每次创建实例都会创建一遍方法

组合继承

原型链继承+经典继承双剑合璧

function Parent(name) {

Parent.prototype.getName = function () { console.log(this.name)

}

function Child(name, age) { Parent.call(this, name);

this.age = age;

}

Child.prototype = new Parent();

Child.prototype.constructor = Child;

var child1 = new Child('kevin', '18');

child1.colors.push('black');

console.log(child1.name); // kevin

console.log(child1.age); // 18

console.log(child1.colors); // ["red", "blue", "green", "black"]

var child2 = new Child('daisy', '20');

console.log(child2.name); // daisy

console.log(child2.age); // 20

console.log(child2.colors); // ["red", "blue", "green"]

融合原型链继承和构造函数的优点，JS最常用继承模式

原型式继承

function createObj(o) { function F(){}

F.prototype = o;

return new F();

}

ES5 Object.create的模拟实现，将传入对象作为创建的对象的原型

var person = { name: 'kevin',

friends: ['daisy', 'kelly'] }

var person1 = createObj(person);

var person2 = createObj(person);

person1.name = 'person1';

console.log(person2.name); // kevin

person1.friends.push('taylor');

console.log(person2.friends); // ["daisy", "kelly", "taylor"]

寄生式继承

创建一个仅用于封装继承过程的函数，该函数在内部以某种形式做增强对象，再返回对象

function createObj(o) { var clone = Object.create(o);

clone.sayName = function () { console.log('hi');

}

return clone;

}

缺点

和借用构造函数一样，每次创建对象都会创建一遍方法

寄生组合式继承

组合继承最大缺点——调用2次父构造方法

1. 设置子实例的原型时
2. 创建子类型的实例时

如何避免重复调用？

如果我们不使用Child.prototype=new Parent()，而是间接让 Child.prototype访问Parent.prototype呢？

}

Parent.prototype.getName = function () { console.log(this.name)

}

function Child(name, age) { Parent.call(this, name);

this.age = age;

}

// 关键的三步

var F = function (){};

F.prototype = Parent.prototype;

Child.prototype = new F();

var child1 = new Child('kevin', '18');

console.log(child1);

封装一下这个继承方法

function object(o) { function F(){}

F.prototype = o;

return new F();

}

function prototype(child, parent) { var prototype = object(parent.prototype); //创建父类原型对象的副本

prototype.constructor = child; //增强对象，补充因重写原型而失去的默认的constructor属性

child.prototype = prototype; //将创建的新副本指定给子类的原型对象 }

// 当我们使用的时候：

prototype(Child, Parent);