js继承

继承

1.所有的函数都有prototype属性，指向原型对象，所有的对象都有一个constructor属性，指向构造函数。
从技术上来讲，js上并不存在继承。js本身不存在面向对象特性，是面向过程的语言。

实现继承的方式（1）原型链继承

var b.prototype = new a();

好处:
（1）比较简单；
（2）在父类的原型中，可以动态的增加属性和方法，而不会影响到a。
缺点：
（1）为子类添加属性和方法时，必须写在var b.prototype = new a();之后，否则，创建b时就是覆盖之前添加的属性和方法。
（2）使用原型链式的继承，不能实现多继承。（不是用的特别多）
（3）所有的属性都是共享的。（不是很严重）
（4）没有办法传递参数。（非常重要的缺点）

解决方式：借用构造函数模式（将父类中的属性重写一遍，在子类中重新运行一遍）

修改this的指向，a.call(this) 或者a.apply(this)。
实际开发代码： 在b中写入a.call(this) 或者a.apply(this)。

function SuperType(){    this.colors = ["red","blue","green"];}function SubType(){    //继承了SuperType    SuperType.call(this);}//SubType.prototype = new SuperType();var instance1 = new SubType();instance1.colors.push("orange");console.log(instance1.colors); //[ 'red', 'blue', 'green', 'orange' ]var instance2 = new SubType();console.log(instance2.colors);//[ 'red', 'blue', 'green' ]

传递参数

function SuperType(name){    this.name = name;}function SubType(){    //继承了SuperType    SuperType.call(this,"lulu");    this.age = 28;}//SubType.prototype = new SuperType();var instance = new SubType();console.log(instance.name);  //luluconsole.log(instance.age);   //28

优点

（1）可以实现多继承
（2）解决了共享问题
（3）可以传递参数

缺点

（1）通过new创建出来的实例只是子类的实例，不是父类的实例。
（2）只能继承构造函数内的属性和方法，不能继承原型中的属性和方法。
（3）所有的属性都是在构造函数中运行的，没法进行复用。

组合模式（伪经典继承）

1.在子类的构造函数中使用call或apply方法，让父类的构造函数重新运行。
2.让子类的原型指向父类的实例。

function SuperType(name){    this.name = name;    this.colors=["red","green","blue"];}SuperType.prototype.sayName = function(){    console.log(this.name);}function SubType(name,age){    //继承了SuperType    SuperType.call(this,name);    this.age = age;}//继承方法SubType.prototype = new SuperType();SubType.prototype.constructor = SubType;SubType.prototype.sayAge = function(){    console.log(this.age);};var instance1 = new SubType("lulu","28");instance1.colors.push("black");console.log(instance1.colors);  //[ 'red', 'green', 'blue', 'black' ]instance1.sayAge(); //28instance1.sayName(); //luluvar instance2 = new SubType("lpy","26");console.log(instance2.colors);//[ 'red', 'green', 'blue' ]instance2.sayAge();   //26instance2.sayName();  //lpy

以上三种方式，有一个共同的前提，就是所有的实例都是通过new创建出来的。
属性在实例和构造函数中各存在一份。

原型式继承

与原型链继承的区别是：原型链继承继承的是构造函数，原型式继承继承的是普通的函数。

function object(o){    function F(){};    F.prototype = o;    return new F();}

从上面的例子可以看出，在object()函数内部，先创建了一个临时性的函数，然后将传入的对象作为这个构造函数的原型，最后返回了这个临时类型的一个新实例。

在ES5中，新增的创建对象方法Object.create()，这个方法接收两个参数：一个用作新对象原型的对象和一个为新对象定义额外属性的对象。在传入一个参数的情况下，Object.create() 与object()方法的行为相同。

//原型式继承var person = {    name:"露露",    friends:["李白","橘右京","阿珂"]};var anotherperson = Object.create(person);anotherperson.name = "花木兰";anotherperson.friends.push("杨戬");var yetAnotherperson = Object.create(person);yetAnotherperson.name="刘备";yetAnotherperson.friends.push("关羽");console.log(person.name+' '+person.friends);//露露 李白,橘右京,阿珂,杨戬,关羽console.log(anotherperson.name+' '+anotherperson.friends);//花木兰 李白,橘右京,阿珂,杨戬,关羽console.log(yetAnotherperson.name+' '+yetAnotherperson.friends);//刘备 李白,橘右京,阿珂,杨戬,关羽

Object.create()的第二个参数的每个属性都是通过自己的描述符定义的。

寄生式继承和原型式继承而思路一样，只不过看起来更像继承。

寄生组合式继承(经典继承)

针对组合模式的缺点（两次调用父类构造函数）我们使用寄生组合式继承（经典继承）。

所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。

function inheritPrototype(SubType,superType){    var p = Object(superType.prototype);    p.constructor = subType;    subType.prototype =p;   }

浅克隆：直接拷贝值（对于对象，则拷贝了引用）
深克隆：先判断数据类型，如果是原始类型，则直接拷贝，如果是对象，则赋值它的子对象的引用，里面所有的变量和子对象都是又额外拷贝了一份。