ES5的类，原型，继承

类
什么是类
类是 面向对象程序设计语言中的一个概念。类（Class）实际上是对某种类型的对象定义变量和方法的原型。
它表示对现实生活中一类具有共同特征的事物的抽象，类的构造函数是类实例化后对象的本地方法和属性，
而类中的方法和属性是所有实例化对象共有的方法和属性，即实例化对象原型上的方法和属性。
类的定义1-构造函数法
第一个Ball的函数，被实例化以后就变成了类，那么这个函数我们把它叫做构造函数，
prototype是Ball的原型链我们可以在类的原型链下面添加属于类的方法和属性。
构造函数中的this，是被实例化以后的对象。

 function Ball() {
        this.name="球";
    }
    Ball.prototype.play=function () {
        console.log("打球");
    };
    var ball=new Ball();
    console.log(ball.name);
    ball.play();

类的定义2-对象创建法
下面那个条件语句是为了在老式浏览器中兼容使用的，实际我们使用仅仅通过Object.create就可以创建一个对象，
这个对象是根据Ball这个对象原型来创建出来的。

   var Ball={
        name:"球",
        play:function () {
            console.log("打球");
        }
    };
    var ball=Object.create(Ball);
    console.log(ball.name);
    ball.play();

类的定义3-极简主义法

  var Ball={
        createNew:function () {
            var ball={};
            ball.name="球";
            ball.play=function () {
                console.log("打球")
            };
            return ball;
        }
    };
    var ball=Ball.createNew();
    console.log(ball.name);
    ball.play();

原型
我们创建的每个函数都有一个prototype(原型）属性，这个属性是一个对象(原型对象)，
它的用途是包含可以由特定类型的所有实例共享的属性和方法。即原型是一种抽象化的表现。
逻辑上可以这样理解：prototype通过调用构造函数而创建的那个对象的原型对象。
使用原型的好处可以让所有对象实例共享它所包含的属性和方法。也就是说，
不必在构造函数中定义对象信息，而是可以直接将这些信息添加到原型中。
而构造函数是每个实例化对象的本地函数和方法，故所有实例化对象的原型引用地址相同，
但是构造器内的方法和属性引用都为每个对象的方法和属性。

   function Box(){}//声明一个构造函数
        Box.prototype.name=”zhang”;//在原型里添加属性
        Box.prototype.age=100;
        Box.prototype.run=function(){//在原型里添加方法
            return this.name+this.age+"运行中……";
        }
        var box1=new Box();    
        var box2=new Box();
        alert(box1.run==box2.run);//true,方法的引用地址保持一致

构造函数属性和方法均是独立的，也就是互不影响

在原型模式声明中，__proto__属性，这个属性是创建对象时自动生成的,
__proto__属性是实例指向原型对象的一个指针，它的作用是指向构造函数的原型属性constructor.
通过这个属性，就可以访问到原型里的属性和方法了。
PS:IE（10及以前的）浏览器在脚本访问__proto__会不能识别，
火狐和谷歌浏览器及其他某些浏览器均能识别。
虽然可以输出，但无法获得内部信息。

判断一个对象是否指向了该构造函数的原型对象，可以使用isPrototypeOf()方法来测试。
alert(Box.prototype.isPrototypeOf(box));//只要实例化对象，即都会指向
原型模式的执行流程：
1、先查找构造函数实例里的属性和方法，如果有，立刻返回；
2、如果构造函数实例里没有，

则去它的原型对象里找，如果有，就返回；

虽然我们可以通过对象实例访问保存在原型中的值，但却不能访问通过对象实例重写原型中的值。
var box1=new Box(); alert(box1.name);//原型里的值
box1.name=”zhang”; alert(box1.name);//就近原则
var box2=new Box();
alert(box2.name);//原型里的值，没有被box1修改
如果想要box1也能在后面继续访问到原型里的值，可以把构造函数里的属性删除即可。具体如下：
delete box1.name; alert(box1.name);

原型可以通过 实例化对象.__proto__来改变，但是我们不能这样做，因为原型原本就是
让所有的子对象继承或者共有的

原型方法
hasOwnProperty:方法会返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。

obj.hasOwnProperty(prop)
isPrototypeOf:方法用于测试一个对象是否存在于另一个对象的原型链上。
    prototypeObj.isPrototypeOf(object)
        function Fee() {}
        function Fi() {}
        Fi.prototype=new Fee();
        function Fo() {}
        Fo.prototype=new Fi();
        function Fun() {}
        Fun.prototype=new Fo();
        var fun=new Fun();
        if(Fi.prototype.isPrototypeOf(fun)){
            console.log("确实挂载在这个原型链下")
        }
        console.log(fun)

propertyIsEnumerable
obj.propertyIsEnumerable(prop)
propertyIsEnumerable() 方法返回一个布尔值，表明指定的属性名是否是当前对象可枚举的自身属性。
枚举就是用for in可以罗列出来的属性

  var o={};
        var a=[];
        o.prop="属性";
        a[0]=3;
        console.log(o.propertyIsEnumerable("prop"));
        console.log(a.propertyIsEnumerable(0))

constructor
任何一个prototype对象都有一个constructor属性，指向它的构造函数
返回一个指向创建了该对象原型的函数引用。

 var o={};
        console.log(o.constructor===Object);
        var a=[];
        console.log(a.constructor===Array);
        var n=4;
        console.log(n.constructor===Number);
        function Tree(name) {
            this.name=name;
        }
        var theTree=new Tree("big");
        console.log(theTree.constructor)
        
        function fn1() {};
        var f1 = new fn1();
        console.log(f1.constructor === fn1); //true
        //替换默认原型
        function fn2() {};
        fn2.prototype = {};
        var f = new fn2();
        console.log(f.constructor === fn2); //false
        console.log(f.constructor === Object); //true

fn2.prototype={}//原本fn2.constructor是fn2本身，这一句把原型中的构造函数给覆盖了，
从而使fn2的构造函数指向了Object。

继承
继承是面向对象中一个比较核心的概念。其他正统面向对象语言都会有两种方式实现继承：
一个是接口实现，一个是继承。而JS只是继承，不支持接口实现，而实现继承的方式依靠原型链完成。

比如，现在有一个"动物"对象的构造函数。

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

还有一个"猫"对象的构造函数。

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

怎样才能使"猫"继承"动物"呢？
一、 构造函数绑定
第一种方法也是最简单的方法，使用call或apply方法，将父对象的构造函数绑定在子对象上，
即在子对象构造函数中加一行：

function Cat(name,color){
　　　　Animal.apply(this, arguments);
　　　　this.name = name;
　　　　this.color = color;
　　}
　　var cat1 = new Cat("大毛","黄色");
　　alert(cat1.species); // 动物

二、 prototype模式
第二种方法更常见，使用prototype属性。
如果"猫"的prototype对象，指向一个Animal的实例，那么所有"猫"的实例，就能继承Animal了。
　　Cat.prototype = new Animal();
　　Cat.prototype.constructor = Cat;
　　var cat1 = new Cat(“大毛”,“黄色”);
　　alert(cat1.species); // 动物
代码的第一行，我们将Cat的prototype对象指向一个Animal的实例。
　　Cat.prototype = new Animal();
它相当于完全删除了prototype 对象原先的值，然后赋予一个新值。但是，第二行又是什么意思呢？
　　Cat.prototype.constructor = Cat;
原来，任何一个prototype对象都有一个constructor属性，指向它的构造函数。
如果没有"Cat.prototype = new Animal();"这一行，Cat.prototype.constructor是指向Cat的；
加了这一行以后，Cat.prototype.constructor指向Animal。
　　alert(Cat.prototype.constructor == Animal); //true
更重要的是，每一个实例也有一个constructor属性，默认调用prototype对象的constructor属性。
　　alert(cat1.constructor == Cat.prototype.constructor); // true
因此，在运行"Cat.prototype = new Animal();"这一行之后，cat1.constructor也指向Animal！
　　alert(cat1.constructor == Animal); // true
这显然会导致继承链的紊乱（cat1明明是用构造函数Cat生成的），因此我们必须手动纠正，
将Cat.prototype对象的constructor值改为Cat。这就是第二行的意思。
这是很重要的一点，编程时务必要遵守。下文都遵循这一点，即如果替换了prototype对象，
　　o.prototype = {};
那么，下一步必然是为新的prototype对象加上constructor属性，并将这个属性指回原来的构造函数。
　　o.prototype.constructor = o;

三、 直接继承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(“大毛”,“黄色”);
　　alert(cat1.species); // 动物
与前一种方法相比，这样做的优点是效率比较高（不用执行和建立Animal的实例了），
比较省内存。缺点是 Cat.prototype和Animal.prototype现在指向了同一个对象，
那么任何对Cat.prototype的修改，都会反映到Animal.prototype。
所以，上面这一段代码其实是有问题的。请看第二行
　　Cat.prototype.constructor = Cat;
这一句实际上把Animal.prototype对象的constructor属性也改掉了！
　　alert(Animal.prototype.constructor); // Cat

四、 利用空对象作为中介
由于"直接继承prototype"存在上述的缺点，所以就有第四种方法，利用一个空对象作为中介。
　　var F = function(){};
　　F.prototype = Animal.prototype;
　　Cat.prototype = new F();
　　Cat.prototype.constructor = Cat;
F是空对象，所以几乎不占内存。这时，修改Cat的prototype对象，就不会影响到Animal的prototype对象。
　　alert(Animal.prototype.constructor); // Animal
我们将上面的方法，封装成一个函数，便于使用。

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

使用的时候，方法如下
　　extend(Cat,Animal);
　　var cat1 = new Cat(“大毛”,“黄色”);
　　alert(cat1.species); // 动物
这个extend函数，就是YUI库如何实现继承的方法。
另外，说明一点，函数体最后一行
　　Child.uber = Parent.prototype;
意思是为子对象设一个uber属性，这个属性直接指向父对象的prototype属性。
（uber是一个德语词，意思是"向上"、“上一层”。）这等于在子对象上打开一条通道，
可以直接调用父对象的方法。这一行放在这里，只是为了实现继承的完备性，纯属备用性质。

五、 拷贝继承
上面是采用prototype对象，实现继承。我们也可以换一种思路，纯粹采用"拷贝"方法实现继承。
简单说，如果把父对象的所有属性和方法，拷贝进子对象，不也能够实现继承吗？这样我们就有了第五种方法。
首先，还是把Animal的所有不变属性，都放到它的prototype对象上。

function Animal(){}
　　Animal.prototype.species = "动物";
然后，再写一个函数，实现属性拷贝的目的。
　　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对象。
使用的时候，这样写：
　　extend2(Cat, Animal);
　　var cat1 = new Cat(“大毛”,“黄色”);
　　alert(cat1.species); // 动物

非构造函数继承
一、什么是"非构造函数"的继承？
比如，现在有一个对象，叫做"中国人"。

var Chinese = {
　　　　nation:'中国'
　　};

还有一个对象，叫做"医生"。

var Doctor ={
　　　　career:'医生'
　　}

请问怎样才能让"医生"去继承"中国人"，也就是说，我怎样才能生成一个"中国医生"的对象？
这里要注意，这两个对象都是普通对象，不是构造函数，无法使用构造函数方法实现"继承"。
二、object()方法
json格式的发明人Douglas Crockford，提出了一个object()函数，可以做到这一点。

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

这个object()函数，其实只做一件事，就是把子对象的prototype属性，指向父对象，
从而使得子对象与父对象连在一起。
使用的时候，第一步先在父对象的基础上，生成子对象：
　　var Doctor = object(Chinese);
然后，再加上子对象本身的属性：
　　Doctor.career = ‘医生’;
这时，子对象已经继承了父对象的属性了。
　　alert(Doctor.nation); //中国
三、浅拷贝
除了使用"prototype链"以外，还有另一种思路：把父对象的属性，全部拷贝给子对象，也能实现继承。
下面这个函数，就是在做拷贝：

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

使用的时候，这样写：
　　var Doctor = extendCopy(Chinese);
　　Doctor.career = ‘医生’;
　　alert(Doctor.nation); // 中国
但是，这样的拷贝有一个问题。那就是，如果父对象的属性等于数组或另一个对象，
那么实际上，子对象获得的只是一个内存地址，而不是真正拷贝，因此存在父对象被篡改的可能。
请看，现在给Chinese添加一个"出生地"属性，它的值是一个数组。
　　Chinese.birthPlaces = [‘北京’,‘上海’,‘香港’];
通过extendCopy()函数，Doctor继承了Chinese。
　　var Doctor = extendCopy(Chinese);
然后，我们为Doctor的"出生地"添加一个城市：
　　Doctor.birthPlaces.push(‘厦门’);
发生了什么事？Chinese的"出生地"也被改掉了！
　　alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
　　alert(Chinese.birthPlaces); //北京, 上海, 香港, 厦门
所以，extendCopy()只是拷贝基本类型的数据，我们把这种拷贝叫做"浅拷贝"。这是早期jQuery实现继承的方式。
四、深拷贝
所谓"深拷贝"，就是能够实现真正意义上的数组和对象的拷贝。它的实现并不难，只要递归调用"浅拷贝"就行了。

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;
　　}

使用的时候这样写：
　　var Doctor = deepCopy(Chinese);
现在，给父对象加一个属性，值为数组。然后，在子对象上修改这个属性：
　　Chinese.birthPlaces = [‘北京’,‘上海’,‘香港’];
　　Doctor.birthPlaces.push(‘厦门’);
这时，父对象就不会受到影响了。
　　alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
　　alert(Chinese.birthPlaces); //北京, 上海, 香港
目前，jQuery库使用的就是这种继承方法。

声明，继承这一块内容摘自与阮一峰老师，感觉实在是写得清晰明了，自己也写不出这样的内容，如有侵犯，望告知，删帖。