javascript __proto___ prototype和Function原代码狂想

----我以为的Function----

1 function Function ( ) {
2       this.prototype = new this() ; /*这就导致了所有的函数的原型都是对象；如：alert(typeof(Array.prototype));输出：object */
3       this.prototype.constructor = this ; // 由上一条推想可得
4       //... ...
5       //[native code]
6       //... ...
7   }

所有的函数：

预定义：

1 function Function () { [native code] }
2  function Object () { [native code] } // Global、Arguments、Math和JSON是Object构建的;
3  function Array () { [native code] }
4  function Date () { [native code] }
5  function String () { [native code] }
6  function Boolean () { [native code] }
7  function Number () { [native code] }
8  function RegExp () { [native code] }

自定义：

1 function Fn () { /*... ...*/ }

所谓的狂想

无论是预定义的（包括Function本身）还是自定义的函数都是由Function new出来的。我们知道，函数new出来的都是对象，那么Function是函数，它new出来的东西（函数）自然也会是对象，所以函数也是对象。

Function new出来的对象是函数，叫“函数对象”（简称“函数”）；这跟

Array new出来的对象叫“数组对象”（简称“数组”）；

Object new出来的对象是“对象对象”（简称“对象”）是一样的道理。

传说的癫疯

__proto__（血缘 或说DNA）：

当用new操作符构造对象时，会在对象和构造函数之间创建__proto__链，该链应该是对外不可见的 (Firefox、chrome可以让我们访问到，但并不建议这样做)。它的引用是恒定的：对象.__proto__ = 该对象构造函数.prototype；但它的值是可变的，这明显取决于：该对象构造函数.prototype的值（废话！）。

prototype：

所有的对象都有__proto__，但只有函数对象（默认）拥有prototype，非函数对象（默认）没有也没必要拥有prototype，这是prototype本身的职能所决定的：Javascript利用prototype实现扩展、共享和继承。

__proto__链、prototype链图：

关于null:注意没有，指向null的箭头有一半是黑色的，这个箭头表示：Object.prototype.__proto__;

为什么是null？

如果根据我猜想的Function构造Object函数，那么：Object.prototype = new Object();

1 alert(Object.prototype)//输出：[ obje Object ]

那么应该是这样的才对啊：Object.prototype.__proto__ = Object.prototype;

看出问题没有？！如果是这样的话对象检索不存在的属性在到达Object的时候就会掉入死循环（专业点叫递归是么，不好意思美工出身）:

1 Object.prototype.__proto__=Object.prototype;
2 var obj={};
3 alert(obj.say)

chrome javascript 控制台 ：

Uncaught Error: Cyclic __proto__ value 

 所以我认为：Object.prototype.__proto__ = null 是特定定义的：

1 alert(Object.prototype.__proto__);
2 //firfox 和 chrome 输出：null
3 //IE9输出：undefined

无论是null还是undefined目的都是一样的，就是为了终止检索。

后遗症：

利用Function.prototype或者Object.prototype可以将方法或属性分享给所有的对像（不仅仅是“对象对象”哦）。原理，看图！

注意：对象检索自身属性无果时会去访问其__proto__而非其prototype（这有点像废话），函数对象的prototype只有由它构建的对象在检索自身属性无果时才会去访问：

1 Array.prototype.selfCheck = "Are you sure?";
2 alert(Array.selfCheck);// 输出:undefined;  自定义的函数亦是如此

但Function和Object会有所不同：

Function.prototype.selfCheck = "Yes!"
alert(Function.selfCheck) ; // 输出："Yes!"，原因如图：Function  __proto__  Function
Object.prototype.selfCheck = "Yes!"
alert(Object.selfCheck);// 输出："Yes!"，原因如图：Object __proto__ Function，Function.prototype是Object

更有意思的：

1 Function.prototype.sayHello="Hi,F";
2 Object.prototype.sayHello="Hi,O";
3 alert(Object.sayHello);//输出：Hi.F

追本溯源：（再说函数也是对象！）

把“函数对象”比作受惊L，那么Function就像是LZ，Function内的“this.prototype = new this()”就像是LZ内的一根JZ啊，受惊L同时拥有LZ和JZ的DNA，“函数对象”就这样同时具备了函数和对象的特性啊！！！

最后说一下constructor属性：

1 //alert("constructor" in 任意对象)  都是ture;
2 //但 任意“对象对象”.hasOwnProperty("constructor")都是fale;

对象的检索到的constructor属性值都是从它们的构造函数那里继承来的，从猜想的Function里面的this.property.constructor = this就可以看出。

转载于:https://www.cnblogs.com/zyfg/archive/2013/01/27/2879233.html