因为之前谢过一篇关于原型对象的笔记：浅谈JavaScript中的原型模式。现在我又重新看到这个话题，对原型有了进一步的理解，所以，又要谈谈原型对象。
一、理解原型对象
创建的每一个函数都有一个prototype属性，它指向这个函数的原型对象。利用原型模式创建的方法和属性是被所有实例所共享的。
function Person(){}
Person.prototype.name="dwqs";
Person.prototype.age=20;
Person.prototype.sayName=function()
{
alert(this.name);
};
var per1 = new Person();
per1.sayName(); //dwqs
var per2 = new Person();
per2.sayName(); //dwqs
alert(per1.sayName == per2.sayName); //true
默认情况下，prototype指向的原型对象自动获取一个constructor属性，指向prototype属性所在的函数，而原型对象的其它方法和属性均从Object继承。
当调用Person的构造函数创建对象per1和per2时，Person的每个实例（per1和per2）均包含一个指向构造函数（Person)的原型对象的指针。ECMA-262第5版给指针取名为[[Prototype]]。
所以，实例中的指针仅指向原型，而不指向构造函数。虽然没有标准的方法直接访问[[Prototype]]特性，但在DOM笔记（十一）中提供了hasOwnProperty()和isPropertyOf()方法来反应原型对象和实例之间的关系。
//isPrototypeOf(obj)检测obj的[[prototype]]是否指向调用此方法的对象
alert(Person.prototype.isPrototypeOf(per1)); //true
alert(Person.prototype.isPrototypeOf(per2)); //true
hasOwnProperty()则是判断属性是存在原型中还是实例中,只有存在实例中时,才返回true。
per1.blog = "www.ido321.com";
alert(per1.hasOwnProperty("blog")); //true
alert(Person.prototype.hasOwnProperty("blog")); //false
alert(per1.hasOwnProperty("name")); //false
alert(Person.prototype.hasOwnProperty("name")); //true
若实例属性和原型属性同名,则同名的原型属性会被屏蔽，但是不会修改原型中的同名属性，当删除同名的实例属性后，又能重新访问被屏蔽的原型属性。
per1.name="i94web";
alert(per1.name); //i94web,来自实例
alert(per2.name); //dwqs 来自原型
delete per1.name;
alert(per1.name); //dwqs
ECMAScript 5提供了Object.getPrototypeOf(obj)来访问obj的[[Prototype]]的指向，即返回obj的原型对象
alert(Object.getPrototypeOf(per1) == Person.prototype); //true
alert(Object.getPrototypeOf(per1).name); //dwqs
二、__proto__属性
在IE11、FireFox、Google等现代浏览器中，每个对象支持__proto__（前后都是两个下划线）属性用于访问父类的原型对象。但要注意的是：
1、原型对象应用__proto__属性时，返回当前类的父类的原型对象的引用；当实例对象应用__proto__属性时，返回当前实例所属类的原型对象的引用。
2、Object.prototype.__proto__返回null，Object没有父类。
3、prototype是静态属性，__proto__是实例属性。
//全是true
alert(Array.prototype.__proto__ == Object.prototype);
alert((new Array()).__proto__ == Array.prototype);
alert(Person.prototype.__proto__ == Object.prototype);
alert(per1.__proto__ == Person.prototype);
alert(Object.prototype.__proto__ == null);
三、重写原型
如果在原型上定义属性或者方法，每次都要将Person.prototype敲一遍，很麻烦。一个简单的方法就是重写原型。
function Person(){}
Person.prototype={
name:"dwqs",
age:20,
sayName:function()
{
alert(this.name);
}
};
var per1 = new Person();
alert(per1 instanceof Object); //true
alert(per1 instanceof Person); //true
alert(per1.constructor == Object); //true
alert(per1.constructor == Person); //false
因为重写了默认的prototype对象，所以constructor属性指向了新对象的constructor属性（Object构造函数），而不是指向Person了。如果constructor指向很重要，可以重新定义：
function Person(){}
Person.prototype={
constructor:Person, //重新定义constructor
name:"dwqs",
age:20,
sayName:function()
{
alert(this.name);
}
};
var per1 = new Person();
alert(per1.constructor == Person); //true
这样设置之后,constructor的特性[[Enumerable]]是true了（参考DOM笔记（十一）），即可以枚举，默认情况下，该属性不可枚举。
正如前文说的，实例中的指针仅指向原型，而不指向构造函数。所以重写原型对象之后，会切断现有原型和任何之前已经存在的对象实例之间的联系。
function Person(){}
//先创建一个实例
var per1 = new Person();
//重写原型
Person.prototype={
constructor:Person,
name:“dwqs”,
age:20,
sayName:function()
{
alert(this.name);
}
};
per1.sayName(); //错误：Uncaught TypeError: undefined is not a function
重写原型对象之前是这样的：
重写原型对象变成这样了：
四、原生对象的原型
所有原生引用类型，如Object、Array、String等都在其构造函数的原型上定义了方法。在Array.prototype上可以找到sort()，在String.prototype上可以找到substring
alert(typeof Array.prototype.sort); //function
alert(typeof String.prototype.substring); //function
因此,也可以在原型对象上为引用类型定义新的方法
String.prototype.startWith=function(str)
{
return this.indexOf(str) == 0;
}
var msg = "Hello world";
alert(msg.startWith("Hello")); //true