一、原型与实例
原型是一个对象
实例是用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;
}
