1 为什么 xx.constructor.prototype 可以访问到当前对象的原型。
'str'.constructor.prototype
     'str'.constructor 指向当前对象的构造函数
          (构造函数).prototype：即函数的prototype 属性
               1 函数有prototype属性，所以可以访问到
               2 函数的prototype属性会在创建实例的时候作为实例的原型而存在。
                    所以 'str'.constructor.prototype 就可以访问到当前对象实例的原型。 
1   
     'str'.constructor  == String
     true.constructor == Boolean
     (1).constructor == Number
     {}.constructor == Object
     [].constructor == Array
     function(){}.constructor == Function
 
 
2
    Array.constructor
    Object.constructor
    Function.constructor
    Number.constructor
    String.constructor
    Boolean.constructor
 
result:全部都是：function Function(){}
推论：
     内置对象的构造器，全部都是 function Function(){},包括Function本身。
     所以js所有的内置对象的构造器都是 function Function(){}
 
 
3
 
     Number.__proto__ === Function.prototype  // true
     Boolean.__proto__ === Function.prototype // true
     String.__proto__ === Function.prototype  // true
     Object.__proto__ === Function.prototype  // true
     Function.__proto__ === Function.prototype // true
     Array.__proto__ === Function.prototype   // true
     RegExp.__proto__ === Function.prototype  // true
     Error.__proto__ === Function.prototype   // true
     Date.__proto__ === Function.prototype    // true
 
4
     Function.prototype.__proto__ == Object.prototype
     Object.prototype.__proto__ == Object.prototype
     Number.prototype.__proto__ == Object.prototype
     Boolean.prototype.__proto__ == Object.prototype
     String.prototype.__proto__ == Object.prototype
     Array.prototype.__proto__ == Object.prototype
     RegExp.prototype.__proto__ == Object.prototype
     Error.prototype.__proto__ == Object.prototype
     Date.prototype.__proto__ == Object.prototype
 
推论：
     1 只有函数才有 prototype属性
     2 所以上面的 XXX.prototype 中的XXX都是构造函数
     3 又有2中的 XXX.__proto__
    所以：XXX既可以是内置对象，也可以是构造函数。根据情景判断。
 
结论： Object的所有实例的原型都是 Object.prototype
 
 
Object.constructor == Function
Function.prototype.__proto__ == Object.prototype;
并且：Object.prototype.__proto__ == null;
 
 
Prototype
 
1 js的对象都拥有内部属性 [[prototype]] 指向其原型对象。
[[prototype]] 被称为 原型属性。
 
2 内部属性不可以直接访问.error: obj[[prototype]],但是可以间接访问 [[prototype]]
    a  ECMA:标准对象原型访问器Object.getPrototype(object)(到目前为止只有Firefox和chrome实现了此访问器);
    b  非标准访问器:__proto__(除了IE)
    c  obj.constructor.prototype
 
js的一切皆是对象，所以 函数也是对象.又因为对象拥有内部属性 [[prototype]],所以
函数也拥有内部属性 [[prototype]].
 
其次:函数同时拥有属性 prototype.prototype属性和 [[prototype]]并非同一个属性。
prototype属性指向一个对象，称为原型对象。
所以：一个函数的原型属性(function’s prototype property ) 和函数实际的原型(prototype)没有关系
 
原型对象的作用：
    当函数fn被用作构造函数时，其所创建的所有实例的 内部属性 [[prototype]] 指向 fn 的 prototype属性。
 
原型的作用：
1 构建原型链
    当对象调用某个方法时,如果其本身不存在此方法,就会往其原型中寻找，直到原型链的顶端。
原型链的作用：
    多个实例都需要的方法可以被抽出放到原型中，从而只需要定义一次，实现多个对象共享方法
 
 
 
Constructor
JS的所有对象都拥有constructor属性，指向其构造函数。
函数的原型对象也是对象,所以原型对象也拥有constructor属性。
并且JS定下了规则：
    fn.prototype.constructor == fn;
    即： 函数的prototype属性的constructor字段,指向当前prototype属性的拥有者，也就是构造函数本身。
 
由 fn.prototype.constructor == fn;推导出来的结论:
    构造函数的实例的 constructor属性 指向其构造函数。
推导：
          var a = new fn();
          首先在a本身寻找:没有找到 constructor属性.再往原型链向上查找，找到a的原型，也就是 fn.prototype,发现了 constructor属性
               所以就相当于 构造函数的实例的 constructor属性始终指向其构造函数。