说明
- prototype属性
prototype 存在于构造函数中 (其实任意函数中都有，只是不是构造函数的时候prototype我们不关注而已) ，他指向了这个构造函数的原型对象。 - constructor属性
constructor属性存在于原型对象中，始终指向创建自身的构造函数，也可以说constructor的定义是要指向原型属性对应的构造函数的，任何function本身严格等于function.prototype.constructor，所以function.prototype是function构造函数的原型（但原型继承需要重新指定function的constructor属性）。
Function // ƒ Function() { [native code] }
Function.prototype.constructor // ƒ Function() { [native code] }
Function === Function.prototype.constructor // true
function Super() {}
Super // ƒ Super() {}
Super.prototype.constructor // ƒ Super() {}
Super === Super.prototype.constructor // true
Super.prototype === Super.prototype.constructor.prototype // true
var su = new Super()
su.constructor // ƒ Super() {}
一个简单的原型继承例子：
function Super() {}
function Sub() {}
Sub.prototype = new Super();
Sub.prototype.constructor = Sub;
var sub = new Sub();
Sub.prototype.constructor === Sub; // 2- true
sub.constructor === Sub; // 4- true
sub.__proto__ === Sub.prototype; // 5- true
Sub.prototype.__proto__ == Super.prototype; // 7- true
这个例子中constructor指向会因为某些原因导致指向变化 Sub.prototype.constructor = Sub;如果不加这一句，会变成Sub.prototype.constructor = Super，也就是上文中说的 constructor属性存在于原型对象中，始终指向创建自身的构造函数。
-
__proto__属性(注意：左右各是2个下划线)
用构造方法创建一个新的对象之后，这个对象中默认会有一个不可访问的属性 [[prototype]] , 这个属性就指向了构造方法的原型对象。 - hasOwnProperty() 方法
hasOwnProperty方法，可以判断一个属性是否来自对象本身。
<script type="text/javascript">
function Person () {
}
Person.prototype.name = "志玲";
var p1 = new Person();
p1.sex = "女";
//sex属性是直接在p1属性中添加，所以是true
alert("sex属性是对象本身的：" + p1.hasOwnProperty("sex"));
// name属性是在原型中添加的，所以是false
alert("name属性是对象本身的：" + p1.hasOwnProperty("name"));
// age 属性不存在，所以也是false
alert("age属性是存在于对象本身：" + p1.hasOwnProperty("age"));
</script>
- isPrototypeOf()方法
isPrototypeOf()函数用于指示对象是否存在于另一个对象的原型链中。如果存在，返回true，否则返回false。
注：isPrototypeOf()与instanceof运算符不同。在表达式object instanceof AFunction中，object 的原型链是针对AFunction.prototype进行检查的，而不是针对AFunction本身。
function Foo() {}
function Bar() {}
function Baz() {}
Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);
var baz = new Baz();
console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(Baz.prototype));//true
console.log(Foo.prototype.isPrototypeOf(Bar.prototype));//true
console.log(Bar.prototype.isPrototypeOf(Foo.prototype));//false
console.log(Foo.prototype.isPrototypeOf(Foo.prototype));//false
- instanceof
instanceof运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性；也可以判断一个实例是否属于某种类型。
语法：object instanceof constructor
// 定义构造函数
function C(){}
function D(){}
var o = new C();
o instanceof C; // true，因为 Object.getPrototypeOf(o) === C.prototype
o instanceof D; // false，因为 D.prototype不在o的原型链上
o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回true
C.prototype instanceof Object // true,同上
- Object.getPrototypeOf()方法
Object.getPrototypeOf()方法返回指定对象的原型（内部__proto__属性指向的原型prototype）。
语法：Object.getPrototypeOf(object)
function Fn(){
}
var fn = new Fn();
//通过getPrototypeOf静态方法，获得对象fn的prototype
var proto = Object.getPrototypeOf(fn);
//将获得的prototype添加一个name属性，并赋值
proto.name = 'Monkey';
//输出对象fn.name
console.log(fn.name); // ==> Monkey
//判断proto是否是Fn.prototype
console.log( 'proto === Fn.prototype? ' + (proto === Fn.prototype) ); // ==> proto === Fn.prototype? true
//判断fn的__proto__是否指向了prototype
console.log( proto.isPrototypeOf(fn)); // true
注意
- 实例化的对象和字面量定义对象与function不具有prototype属性，直接定义函数或者
new Function()创建的函数是具有prototype属性的
var str = new String('ss'); // ==>str 不具有prototype属性
<-------------------------------------------------------------------
var obj = new Object('ss'); // ==>obj 不具有prototype属性
<-------------------------------------------------------------------
function test(){
}
var tf = new test(); // ==>这里面 test 具有prototype属性，但 tf 不具有
<-------------------------------------------------------------------
var fn = new Function(); // ==> fn 具有prototype属性
- Object Created by Function
