javascript深不可测的难点之原型链，你真的理解prototype和__proto__吗？

javascript深不可测的难点之原型链，,你真的理解prototype和__proto__吗？

注意内置对象可以直接取到自己prototype上的方法;

原因是内置对象的__proto__被默认改成指向自己的prototype。

Function.prototype.b = function() {console.log('Function.prototype.b')};
Function.b();//Function.prototype.b

我们自己定义的function hsj(){},它的hsj.proto == Function.prototype

下面是一个经典的案列（包含实例对象）：

var F = function() {console.log('F')};
Object.prototype.a = function() {console.log('Object.prototype.a')};
Function.prototype.b = function() {console.log('Function.prototype.b')};
var f = new F();
//问：能否通过f取到方法a，方法b?
f.a();//yes，间接命中，可以取到。
f.__proto__.a();//yes，间接命中，可以取到。
f.__proto__.__proto__.a();//yes，直接命中，可以取到。
			
//f.b();-error，无法取到
f.constructor.constructor.b();//yes，间接命中，可以取到。f.constructor=F(){},f.constructor.constructor = Function(){},Function.__proto__ = Function.prototype
f.__proto__.constructor.constructor.b();//yes，间接命中，可以取到。f.__proto__.constructor = F(){}
Function.b();//yes,间接命中，可以取到

//====实例f改变原型链,然后f.b()可以访问====
f.__proto__ = Function.prototype;//或者f.__proto__ = Function.__proto__; //原因是内置对象的__proto__被默认改成指向自己的prototype
f.b();//yes
			
/**
* 注意内置对象可以直接取到自己prototype上的方法【仅限内置对象Function，其余Date/Number等内置对象同自定义】;
  原因是内置对象的__proto__被默认改成指向自己的prototype。
  Function.prototype.b = function() {console.log('Function.prototype.b')};
  Function.b();//Function.prototype.b
  我们自己定义的function hsj(){},它的hsj.__proto__ == Function.prototype
*/
 function hsj() {console.log('hsj')};
 hsj.prototype.c = function () {console.log('hsj.prototype.c')};
 hsj.a();//yes,hsj.__proto__.__proto__.a()
 hsj.b();//yes,hsj.__proto__.__proto__.b()
 //hsj.c();-error,注意，自己不可访问同级别的prototype，prototype原则上给实例对象或者hsj.__proto__ == Function.prototype
 console.log(hsj.__proto__ == Function.prototype)//yes
 console.log(Function.__proto__)//Function.__proto__==Function.prototype
 console.log(Function.prototype)//Function.__proto__==Function.prototype

总结①：自定义function实例对象，自定义function对象，基本内置对象Function的三角恋关系：

Function
function self(){}
var instance_self = new self()
我们从下到上说起:
instance_self.prototype == undefined
instance_self.__proto__ == self.prototype
self.prototype.prototype == undefined
self.prototype.__proto__ == Object.prototype
self.__proto__ == Function.prototype

总结②：一直忘记提的一点，就是（自己的原型的构造器就是自己本身）:

Function
function self(){}
var instance_self = new self()
我们从下到上说起：
instance_self.constructor == self
self.prototype.constructor == self
self.constructor == Function
Function.constructor == Function//内部的自己的构造器就是自己
Function.prototype.constructor == Function//自己的原型的构造器就是自己

总结③：写在最后，内置对象Function和内置对象Object的关系：

Function和Object
Function.__proto__ == Function.prototype
Function.prototype == Function.__proto__
Function.prototype.prootype == undefined
//其实Function和Object的真正的关联纽带，最终Function指向Object.prototype,Object则通过Object.prototype指向了未知
Function.prototype.__proto__ == Object.prototype 

 //特殊，不像：Function.__proto__ == Function.prototype；其实Function和Object的真正的关联纽带，最终Function指向Object.prototype,Object则通过Object.prototype指向了未知
Object.__proto__== Function.prototype
Object.prototype == Function.prototype.__proto__
Object.protoype.prototype == undefined
Object.prototype.__proto__ == null