JS继承体系

一、原型与实例

原型是一个对象
实例是用new来从原型对象生成的一个实例对象
new命令后面跟的不是类，而是构造函数。所谓"构造函数"，其实就是一个普通函数，但是内部使用了this变量。对构造函数使用new运算符，就能生成实例，并且this变量会绑定在实例对象上。

//一个叫做DOG的构造函数，表示狗对象的原型
function DOG(name){
　　this.name = name;
}

//对这个构造函数使用new，就会生成一个狗对象的实例。
var dogA = new DOG('大毛');
alert(dogA.name); // 大毛

dogA 自动含有一个constructor属性，指向它们的构造函数。

alert(dogA .constructor == DOG); //true

JS还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。

alert(dogA instanceof DOG); //true

二、new运算符的缺点

用构造函数生成实例对象，有一个缺点，那就是无法共享属性和方法。
比如，在DOG对象的构造函数中，设置一个实例对象的共有属性species。

function DOG(name){
　　this.name = name;
　　this.species = '犬科';
}
//然后，生成两个实例对象：
var dogA = new DOG('大毛');
var dogB = new DOG('二毛');

这两个对象的species属性是独立的，修改其中一个，不会影响到另一个。

dogA.species = '猫科';
alert(dogB.species); //显示犬科，不受dogA的影响

每一个实例对象，都有自己的属性和方法的副本，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这不仅无法做到数据共享，也是极大的资源浪费。

三、prototype属性的引入

考虑到第二点，JS创始人决定为构造函数设置一个prototype属性。
这个属性包含一个对象（以下简称"prototype对象"），所有实例对象需要共享的属性和方法，都放在这个对象里面；那些不需要共享的属性和方法，就放在构造函数里面。
实例对象一旦创建，将自动引用prototype对象的属性和方法。也就是说，实例对象的属性和方法，分成两种，一种是本地的，另一种是引用的。

//还是以DOG构造函数为例，现在用prototype属性进行改写：
function DOG(name){
　　this.name = name;
}
DOG.prototype = { species : '犬科' };
var dogA = new DOG('大毛');
var dogB = new DOG('二毛');
alert(dogA.species); // 犬科
alert(dogB.species); // 犬科

现在，species属性放在prototype对象里，是两个实例对象共享的。只要修改了prototype对象，就会同时影响到两个实例对象。

DOG.prototype.species = '猫科';
alert(dogA.species); // 猫科
alert(dogB.species); // 猫科

由于所有的实例对象共享同一个prototype对象，那么从外界看起来，prototype对象就好像是实例对象的原型，而实例对象则好像"继承"了prototype对象一样。

原型链

当我们访问一个对象的属性时，如果这个对象内部不存在这个属性，那么他就会去prototype里找这个属性，这个prototype又会有自己的prototype，于是就这样一直找下去，一直检索到 Object 内建对象，这就是原型链的概念。

四、 Prototype模式的验证方法

1、 isPrototypeOf()
这个方法用来判断，某个proptotype对象和某个实例之间的关系。

alert(DOG.prototype.isPrototypeOf(dogA)); //true
alert(DOG.prototype.isPrototypeOf(dogB)); //true

2、 hasOwnProperty()
每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。

alert(dogA.hasOwnProperty("name")); // true
alert(dogA.hasOwnProperty("species")); // false 不是自身属性，而是继承prototype对象的属性

3、 in运算符
in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。

alert("name" in dogA); // true
alert("species" in dogA); // true

in运算符还可以用来遍历某个对象的所有属性。

for(var prop in dogA) { 
    alert("dogA["+prop+"]="+dogA[prop]); 
}

五、构造函数的继承

两个构造函数：

function Animal(){
　　this.species = "动物";
}

function Cat(name,color){
　　this.name = name;
　　this.color = color;
}

（1）构造函数绑定（call、apply）

function Cat(name,color){
　　Animal.apply(this, arguments);  //Animal是属性绑定到Cat的实例上
　　this.name = name;
　　this.color = color;
}
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

（2）prototype模式

Cat.prototype = new Animal();
Cat.prototype.constructor = Cat; //手动纠正
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

constructor属性默认指向它的构造函数。
如果没有"Cat.prototype = new Animal();"这一行，Cat.prototype.constructor是指向Cat的；
加了这一行以后，Cat.prototype.constructor指向Animal，同样其产生的实例cat1.constructor也指向Animal
这显然会导致继承链的紊乱（cat1明明是用构造函数Cat生成的），因此我们必须手动纠正，将Cat.prototype对象的constructor值改为Cat。这就是第二行的意思。

（3）直接继承prototype

Cat.prototype = Animal.prototype;

与前一种方法相比，这样做的优点是效率比较高（不用执行和建立Animal的实例了），比较省内存。缺点是 Cat.prototype和Animal.prototype现在指向了同一个对象，那么任何对Cat.prototype的修改，都会反映到Animal.prototype。比如像代码Cat.prototype.constructor = Cat;实际上把Animal.prototype对象的constructor属性也改掉了

（4）利用空对象作为中介

function extend(Child, Parent) {
　　var F = function(){};
　　F.prototype = Parent.prototype;
　　Child.prototype = new F();
　　Child.prototype.constructor = Child;
　　Child.uber = Parent.prototype;
}

extend(Cat,Animal);
var cat1 = new Cat("大毛","黄色");
alert(cat1.species); // 动物

F是空对象，所以几乎不占内存。这时，修改Cat的prototype对象，就不会影响到Animal的prototype对象。

（5）拷贝继承

function extend2(Child, Parent) {
　　var p = Parent.prototype;
　　var c = Child.prototype;
　　for (var i in p) {
　　　　c[i] = p[i];
　　}
　　c.uber = p;
}

就是将父对象的prototype对象中的属性，一一拷贝给Child对象的prototype对象。

六、非构造函数的继承

两个对象

var Chinese = {
　　nation:'中国'
};
var Doctor ={
　　career:'医生'
}

（1）object()方法

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

就是把子对象的prototype属性，指向父对象，从而使得子对象与父对象连在一起。

//第一步先在父对象的基础上，生成子对象
var Doctor = object(Chinese);
//然后，再加上子对象本身的属性：
Doctor.career = '医生';
alert(Doctor.nation); //中国 子对象已经继承了父对象的属性了

（2）浅拷贝

除了使用"prototype链"以外，还有另一种思路：把父对象的属性，全部拷贝给子对象，也能实现继承。

function extendCopy(p) {
　　var c = {};
　　for (var i in p) { 
　　　　c[i] = p[i];
　　}
　　c.uber = p;
　　return c;
}

这样的拷贝有一个问题。那就是，如果父对象的属性等于数组或另一个对象，那么实际上，子对象获得的只是一个内存地址，而不是真正拷贝，因此存在父对象被篡改的可能。

（3）深拷贝（递归拷贝）

function deepCopy(p, c) {
　　var c = c || {};
　　for (var i in p) {
　　　　if (typeof p[i] === 'object') {
　　　　　　c[i] = (p[i].constructor === Array) ? [] : {};
　　　　　　deepCopy(p[i], c[i]);
　　　　} else {
　　　　　　c[i] = p[i];
　　　　}
　　}
　　return c;
}