写完这篇文章，再也不用怕面试官问到继承了。
看看阮一峰大神的文章是怎么写的，他提到两种继承：
1、构造函数的继承
2、非构造函数的继承
下面是一个“动物“对象的构造函数
function Animal(){ this.species='动物'}；
还有一个”猫“对象的构造函数
function Cat(name,color){
this.name=name;
this.color=color;
}
怎样让”猫“继承”动物“呢？
构造函数的继承
一、构造函数绑定（只继承私有属性）
function Cat(name,color){
Animal.apply(this,arguments);
this.name=name;
this.color=color;
}
var cat1=new Cat('小花','白色')
console.log(cat1.species);//动物
二、prototype模式（原型链继承）
如果”猫“的prototype对象，指向一个Animal的实例，那么所有”猫“的实例，就能继承Animal了。
Cat.prototype=new Animal();
Cat.prototype.constructor=Cat;
var cat1=new Cat('小花'，‘白色’);
console.log(cat1.species);//动物
第一行代码，Cat的prototype对象指向了Animal的实例。
它相当于删除了prototype对象原先的值，然后赋予一个新的值。但是第二行又是什么意思呢？
原来，任何一个prototype对象都自带一个constructor的属性，指向它的构造函数。如果没有Cat.prototype=new Animal()这一行，Cat.prototype.constructor是指向Cat的，加了这一行后，Cat.prototype.constructor指向了Animal。
console.log(Car.prototype.constructor==Animal);//true
更重要的是，每一个实例也有一个constructor属性，它也会指向当前的这个类
console.log(Cat.prototype.constructor == Animal);//true;
因此，在运行Cat.prototype=new Animal();这一行之后，cat1.constructor也指向了Animal了，这显然造成了继承链的紊乱，所以必须把constructor指向改过来，即
Cat.prototype.constructor=Cat;
三、直接继承prototype
第三种方法是对第二种方法的改进。由于Animal队形中，不变的属性都可以直接写入Animal.prototype。所以，我们也可以让Cat()跳过Animal，直接继承Animal.prototype。
现在我们将Animal对象改写:
function Animal(){ };
Animal.prototype.species='动物';
然后，将Cat的prototype对象，然后指向Animal的prototype对象，这样就完成了继承。
Cat.prototype=Animal.prototype;
Cat.prototype.constructor=Cat;
var cat1=new Cat('小花','yellow');
console.log(cat1.species);//动物
这种做法的好处是，效率比较高（不用执行和建立Animal的实例了），比较省内存。缺点是Cat.prototype和Animal.prototype现在指向了同一个对象，那么任何对Cat.prototype的修改，都会反映到Animal.prototype。
所以，上面的代码是有问题的，请看第二行
Cat.prototype.constructor=Cat;
相当于把Animal.prototype.constructor也改掉 了。
四、拷贝继承
这是用纯粹的“拷贝”来实现继承。简单说，如果把父对象的所有属性和方法，拷贝进子对象，不也能实现继承吗？
首先，还是把Animal的所有不变属性，都放到它的 prototype对象上。
function Animal(){ }
Animal.prototype.species='动物';
然后在写一个函数，实现拷贝的目的。
function extend(Child,Parent){
var p=Parent.prototype;
var c=Child.prototype;
for (var i in p){
c[i]=p[i];
}
}
使用的时候，这么写：
extend(Cat,Animal);
var cat1=new Cat('小花'，'白色')；
console.log(cat1.species);//动物
非构造函数的继承
非构造函数继承，即不使用构造函数实现“继承”；
一、什么是“非构造函数”的继承？
比如,现在有一个对象，叫做“中国人”。
var Chinese = { nation : '中国' }
还有一个对象，叫做“医生”
var Doctor = {career : '医生'}
怎样才能让“医生”去继承“中国人”，也就是说，怎么得到“中国医生”这个对象？
二、Object.create()方法
它的意思是，把子对象的prototype属性，指向父对象，从而子对象与父对象连在了一起
实现原理
function create(o){
function Fn(){};
Fn.prototype=o;
return new Fn();
}
它是这么用的
var Doctor=Object.create(Parent);
然后，再加上对象本身的属性：
Doctor.career='医生';
这时，子对象已经继承了父对象的属性了。
console.log(Doctor.nation);//中国
三、浅拷贝
除了使用prototype链意外，还有另一种思路：把父对象的属性，全部拷贝给子对象，也能实现继承。
下面这个函数，实现了浅拷贝：
function shallowCopy(p){
var c={};
for(var i in p){
c[i]=p[i];
}
return c;
}
使用的时候，这样写:
var Doctor=shallowCopy(Chinense);
Doctor.career='医生';
console.log(Doctor.nation); //中国
初学者可能认为这是一个深拷贝，但是有没有考虑过
Chinese.city=['北京','上海','广州'];
这种情况下，对于引用数据类型拷贝，拷贝的只是地址而已，不管在哪个对象里更改这个数据，另外一个也会跟着改。
深拷贝
所谓“深拷贝”，就是能够实现真正意义上的数组和对象的拷贝，它的拷贝并不难，只要递归调用就行了。
function deepClone(c,p){
var c=c||{};
for(var i in p){
if(typeof p[i] === 'object'){
c[i] = c[i] instanceof Array?[]:{};
deepClone(c[i],p[i]);
} else{
c[i] = p[i];
}
}
}
使用方法：
var Doctort = deepClone(Chinese);
放上一张图，理解起来更直观。
