原型链

js中的对象分为两种：普通对象object和函数对象function。

1. var obj1 = new fn1();
2.  var obj2 = {};
3.  var obj3 = new Object();
4.  var obj4 = Object();  

1. function fn1(){};
2.  var fn2 = function(){};
3.  var fn3 = new Function();
4.  var fn4 = Function();

　　　　console.log(typeof obj1);//object
　　　　console.log(typeof obj2);//object
　　　　console.log(typeof obj3);//object
　　　　console.log(typeof obj4);//object

　　　　console.log(typeof fn1);//function
　　　　console.log(typeof fn2);//function
　　　　console.log(typeof fn3);//function
　　　　console.log(typeof fn4);//function

所有的构建函数比如Function、Object、Number等等都是函数对象，这个共知的。

　　　　//所有的构建函数都是function类型的
　　　　console.log(typeof Object);//function
　　　　console.log(typeof Function);//function
　　　　console.log(typeof Number);//function

所有的构建函数使用new或者直接调用方式都能构建出一个新的数据类型。但是构建出来的数据有区别的。

　　　　var o = new Object(),
　　　　    o1 = Object();
　　　　console.log(o == o1);//false
　　　　console.log(o === o1);//false

　　　　var f = new Function(),
　　　　    f1 = Function();
　　　　console.log(f == f1);//false
　　　　console.log(f === f1);//false


　　　　var a = new Array(),
　　　　　a1 = Array();
　　　　console.log(a == a1);//false
　　　　console.log(a === a1);//false

　　　　var n = new Number(),
　　　　n1 = Number();
　　　　console.log(n == n1);//**********************true
　　　　console.log(n === n1);//false

　　　　var s = new String(),
　　　　s1 = String();
　　　　console.log(s == s1);//**********************true
　　　　console.log(s === s1);//false

　　　　var b = new Boolean(),
　　　　b1 = Boolean();
　　　　console.log(b == b1);//**********************true
　　　　console.log(b === b1);//false

//数据类型null/undefined是没有构造函数的

Object/Function/Array的对比结果都好说，因为他们构建出来的都是新的对象，对象比较是要比较根源（数据是否是同一个）。无论是使用new还是直接调用生成一个新的对象是要开辟新的空间存储的，不会和任何一个对象相等。但是对于数值类型，比较符“==”只是比较值相等，比较符"==="除了比较值以外还要比较数据类型。

构造函数，实例，原型与原型对象之间的关系：

每创建一个函数，该函数都会自动带有一个prototype属性。该属性是一个指针，指向一个对象，该对象称之为原型对象(后期我们可以使用这个原型对象帮助我们在js中实现继承)。

原型对象上默认有一个属性constructor,该属性也是一个指针，指向其相关联的构造函数。

通过调用构造函数产生的实例对象，都拥有一个内部属性prototype，指向了原型对象。其实例对象能够访问原型对象上的所有属性和方法。

三者的关系是，每个构造函数都有一个原型对象，原型对象上包含着一个指向构造函数的指针，而实例都包含着一个指向原型对象的内部指针。通俗的说，实例可以通过内部指针访问到原型对象，原型对象可以通过constructor找到构造函数。

原型链：

所有的实例都有一个内部指针指向他的原型对象，并且可以访问到原型对象上的所有属性和方法。person实例对象指向了People的原型对象，可以访问People原型对象上的所有属性和方法。如果People原型对象变成了某一个类的实例aaa,这个实例又会指向一个新的原型对象AAA,那么person此时能访问aaa的实例属性和AAA原型对象上的所有属性和方法了。同理新的原型对象AAA碰巧又是另外一个对象的实例bbb,这个对象实例指向原型对象BBB，那么person就能访问bbb的实例属性和BBB原型上的属性和方法了。