什么是原型？

原型是Javascript中的继承的继承，JavaScript的继承就是基于原型的继承。

函数的原型对象

在JavaScript中，我们创建一个函数A(就是声明一个函数), 那么浏览器就会在内存中创建一个对象B，而且每个函数都默认会有一个属性 prototype 指向了这个对象( 即：prototype的属性的值是这个对象 )。这个对象B就是函数A的原型对象，简称函数的原型。这个原型对象B 默认会有一个属性 constructor 指向了这个函数A ( 意思就是说：constructor属性的值是函数A )。

<script>
    function Person() {
        Person.prototype.name="李五";
        Person.prototype.eat=function () {
        }
    }
    var p1=new Person()
    var p2=new Person()
    console.log(p1.name)
    console.log(p2.name)//输出的都是李五
    //p1.name="张三" //只能改变它本身的值不能修改原型对象共享的值
    //console.log(p1.name) 输出的是张三
    //可通过_proto_修改原型对象中的值 因为
    //console.log(Person.prototype===p1._proto_)
    //console.log(Person.prototype.constructor===Person)
    p2.__proto__.name="小吴";//修改了对象中的值 后边输出的都是小吴

    console.log(p1.name)
    console.log(p2.name)
</script>

说明：

1. 从上面的图示中可以看到，创建p1对象虽然使用的是Person构造函数，但是对象创建出来之后，这个p1对象其实已经与Person构造函数没有任何关系了，p1对象的[[ proto ]]属性指向的是Person构造函数的原型对象。
2. 如果使用new Person()创建多个对象，则多个对象都会同时指向Person构造函数的原型对象。
3. 我们可以手动给这个原型对象添加属性和方法，那么p1,p2,p3...这些对象就会共享这些在原型中添加的属性和方法。
4. 如果我们访问p1中的一个属性name，如果在p1对象中找到，则直接返回。如果p1对象中没有找到，则直接去p1对象的[[proto]]属性指向的原型对象中查找，如果查找到则返回。(如果原型中也没有找到，则继续向上找原型的原型---原型链。 后面再讲)。
5. 如果通过p1对象添加了一个属性name，则对p1对象来说就屏蔽了原型中的属性name。 换句话说：在p1中就没有办法访问到原型的属性name了。
6. 通过p1对象只能读取原型中的属性name的值，而不能修改原型中的属性name的值。 p1.name = "李四"; 并不是修改了原型中的值，而是在p1对象中给添加了一个属性name。

与原型有关的几个属性和方法

prototype属性
prototype 存在于构造函数中 (其实任意函数中都有，只不过不是构造函数的时候prototype我们不关注而已) ，他指向了这个构造函数的原型对象。

constructor属性
constructor属性存在于原型对象中，他指向了构造函数

proto 属性(注意：左右各是2个下划线)
用构造方法创建一个新的对象之后，这个对象中默认会有一个不可访问的属性 [[proto]] , 这个属性就指向了构造方法的原型对象。

hasOwnProperty() 方法
hasOwnProperty方法，可以判断一个属性是否来自对象本身。
hasOwnProperty这个方法可以判断一个属性是否在对象本身添加的，但是不能判断是否存在于原型中，因为有可能这个属性不存在。

in 操作符
in操作符用来判断一个属性是否存在于这个对象中。但是在查找这个属性时候，先在对象本身中找，如果对象找不到再去原型中找。换句话说，只要对象和原型中有一个地方存在这个属性，就返回true

组合使用原型模型和构造函数模型创建对象

原型模型创建对象的缺陷
原型中的所有的属性都是共享的。也就是说，用同一个构造函数创建的对象去访问原型中的属性的时候，大家都是访问的同一个对象，如果一个对象对原型的属性进行了修改，则会反映到所有的对象上面。

使用构造函数模型创建对象的缺陷
在构造函数中添加的属性和方法，每个对象都有自己独有的一份，大家不会共享。这个特性对属性比较合适，但是对方法又不太合适。

使用组合模式解决上述两种缺陷
原型模式适合封装方法，构造方法模式适合封装属性，综合两种模式的优点就有了组合模式。

<script>
    function Person(name,age) {
        this.name=name;
        this.age=age;
        //属性不共享
    }
    Person.prototype.eat=function () {
        console.log("玩"+this.name)
    }//方法共享
    Person.prototype.speak=function () {
        console.log("是"+this.age)

    }
    var p1=new Person("张三",21)
    var p2=new Person("王五",32)
    console.log(p1.name)
    p1.eat()
    console.log(p2.name)
    p1.speak()
</script>

动态原型模式创建对象
动态原型模式把所有的属性和方法都封装在构造方法中，而仅仅在需要的时候才去在构造方法中初始化原型，又保持了同时使用构造函数和原型的优点。

<script>
    function Person(name,age) {
        this.name=name;
        this.age=age;
        if(!Person.prototype.eat){
            Person.prototype.eat=function () {
                console.log("吃"+this.name)
            }
        }
        if(!Person.prototype.speak){
            Person.prototype.speak=function () {
                console.log("玩"+this.age)

            }
        }

    }
    var p1=new Person("a",20)
    var p2=new Person("b",30)
    console.log(p1.speak==p2.speak)//返回true
</script>

说明：

1. 构造函数和普通函数仅仅也仅仅是调用方式的不同。也就是说，随便一个函数你如果用new 的方式去使用，那么他就是一个构造函数。
2. 为了区别，如果一个函数想作为构造函数，作为国际惯例，最好把这个构造函数的首字母大写。