通过构造函数F创建的对象实例p 这个对象p的原型对象是 构造函数中prototype属性指向的对象s，
这个对象p中也有个非标准的__proto__属性指向构造函数prototype属性
所指向的对象s，所以就有 p.__proto__ === F.prototype;
在对象P的原型对象s中有个属性constructor属性，指向的是构造函数本身。
如果对象p的原型对象s被重写，那么P的构造函数不再是F，而是Object
例如：
function F(){};
var p = new F();
console.log(p.__proto__ === F.prototype)//true
console.log(p.constructor === F) //true
console.log(p instanceof F) //true
F.prototype = {};//重写原型对象
p2 = new F() //重新实例一个对象p2
console.log(p instanceof F,p2 instanceof F) //false,true instanceof运算符返回一个布尔值，
//instanceof运算符可以用来判断某个构造函数的prototype属性是否存在另外一个要检测对象的原型链上。
//instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。
/*
Instanceof的判断队则是：沿着A的__proto__这条线来找，同时沿着B的prototype这条线来找，如果两条线能找到同一个引用，即同一个对象，那么就返回true。如果找到终点还未重合，则返回false。
*/
console.log(p.constructor === F) //true
console.log(p2.constructor === F)//false
console.log(p2.constructor === Object)//true
//我们重写F.prototype的时候，并没有改变p1属性prototype的指向，它指向的还是老的那个F.prototype 对象
//原型的动态性 强调的前提是同一个原型对象，即对象（p1）指向的原型对象和类（F）指向的原型对象是同一个，
//当发生原型对象重写的时候，实际上是有个两个原型对象的，一个新的，一个老的。
instanceof 复杂用法：
function Ben() {}
console.log(Object instanceof Object); //true
console.log(Function instanceof Function); //true
console.log(Function instanceof Object); //true
console.log(Ben instanceof Function); //true
console.log(String instanceof String); //false
console.log(Boolean instanceof Boolean); //false
console.log(Ben instanceof Ben); //false
在这里构造函数F也是对象，所以F也有原型对象s2,F的原型对象s2 是 构造函数Function中原型属性prototype所指向的原型对象s2；
Function函数也是对象所以，Function函数的构造函数也是Function...因此所有函数都是由Function构造函数的实例（包括function Object(){}）
Function的原型属性prototype指向的对象和Function的原型对象__proto__ 指向的对象相等 并且Function.__proto__对象是一个特殊的函数对象，
不具有prototype属性
console.log(F.__proto__ === Function.prototype)//true
console.log(Function.__proto__ === Function.prototype) //true function(){}
console.log(Function.__proto__.__proto__ === Object.prototype)//true
console.log(Object.prototype.__proto__ === null)//true
对象字面量产生的对象连接到Object.prototype。函数对象连接到Function.prototype(该原型对象本身连接到Object.prototype).
最后一张图理解Object和Function
(转)：