一 原型继承
function Parent(){
this.color = 'red'
}
Parent.prototype.getName = function(){
console.log(this.name)
}
function Child(){}
Child.prototype = new Parent();//将父类的实例赋给子类的原型
var child1 = new Child();
child1;
child1通过指针__proto__指向其原型对象（其原型对象又指向他的原型对象），其原型对象分为两部分，从构造函数中继承的实例属性color，和从原型对象中继承的。
补充：原型对象的构造函数是函数本身，因此每个构造函数的prototype对象可以看做一个实例化对象。
优点：可以继承构造函数属性，也可继承原型属性。
缺点：
1.首先属性值为引用类型值的原型属性被修改后可能会影响到所有的实例，而该种继承方式中，构造函数中的属性会继承到子类型，成为子类的原型对象的属性。（这也是为什么要在构造函数中定义属性，在原型中定义公共方法）
2.在创建子类的实例时，不能向父类的构造函数中传递参数。
二.借用构造函数
function Parent(name){
this.name = name;
this.colors = ['red','green','pink'];
}
Parent.prototype.getName = function(){
console.log(this.name)
}
function Child(){
Parent.call(this,'Mary');//使用call()方法继承父类构造函数中的属性
this.age = '18';
}
var child1 = new Child();
var child2 = new Child();
优点：避免了原型继承中的两个缺点，可以向父类传参，且不会造成原型属性共享的问题（因为父类构造函数中的属性继承到子类构造函数中，而非原型对象中）。
缺点：不能继承原型属性，无法实现函数复用，所有方法都只能放在构造函数中。
三.组合继承
functionSuperType(name){
this.name = name;
this.colors = ["red","blue","green"];
}
SuperType.prototype.sayName =function(){
alert(this.name);
}
functionSubType(name, age){
// 继承属性
SuperType.call(this, name);
this.age = age;
}
// 继承方法
SubType.prototype =newSuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge =function(){
alert(this.age);
};
varinstance1 =newSubType("Nicholas",29);
instance1.colors.push("black");
alert(instance1.colors);//"red,blue,green,black"
instance1.sayName();//"Nicholas";
instance1.sayAge();//29
varinstance2 =newSubType("Greg",27);
alert(instance2.colors);//"red,blue,green"
instance2.sayName();//"Greg";
instance2.sayAge();//27
2.核心：把 实例函数放在原型对象上，以实现函数的复用。同时还要保留借用构造函数方式的优点，通过Super.call(this)；继承父类的基本属性和引用属性并且能够保留传参的优点，通过Sun.prototype = new Super();继承父类函数，以实现函数复用
优缺点：
优点：
1.不存在引用属性共享的问题
2.可传递参数
3.函数可复用
缺点：
1.子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的（在代码的注释部分给予解释），内存浪费
四.原型链继承
function Person(){ } Person.prototype.hello = "hello"; Person.prototype.sayHello = function(){ alert(this.hello); }
function Child(){ }
Child.prototype = new Person();//这行的作用是：将Parent中将所有通过prototype追加的属性和方法都追加到Child，从而实现了继承
Child.prototype.world = "world";
Child.prototype.sayWorld = function(){
alert(this.world);
}
var c = new Child(); c.sayHello(); c.sayWorld();
优点：简单，易于实现
缺点：
。1.修改sub1.arr之后sub2.arr也发生了改变，因为来自原型对象的引用属性是所有实例共享的
可以这样理解执行过程：
执行sub1.arr.push(2)是先对sub1进行属性查找，找遍实例属性（在这个例子中未定义实例属性）,没找到就顺着原型链向上找，找到了sub1的原型对象，发现arr属性，于是在arr末尾插入2,所以sub2.arr也变了
2.创建子类实例时，无法向父类构造函数传参数
五.寄生式继承
function beget(obj){
var F = function(){};
F.prototype = obj;
return new F();
}
function Super(){
this.val = 1;
this.arr = [1];
}
function getSubObject(obj){
//创建新对象
var clone = beget(obj);//核心
clone.attr1 = 1;
clone.attr2 = 2;
return clone;
}
var sub= getSubObject(new Super());
console.log(sub.val);
console.log(sub.arr);
console.log(sub.arr1);
核心：
给原型式继承穿了个马甲
注意:beget函数不是必须的，创建对象-增强-返回该对象，这样的过程叫做寄生式继承，新的对象是如何创建的不重要
优缺点：
优点：1.不需要创建自定义类型
缺点：1.无法实现函数的复用
