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);  //lulu
console.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(); //28
instance1.sayName(); //lulu
var instance2 = new SubType("lpy","26");
console.log(instance2.colors);//[ 'red', 'green', 'blue' ]
instance2.sayAge();   //26
instance2.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;   
}

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