JavaScript原型链以及Object，Function之间的关系

JavaScript里任何东西都是对象，任何一个对象内部都有另一个对象叫__proto__，即原型，它可以包含任何东西让对象继承。当然__proto__本身也是一个对象，它自己也有自己的__proto__，这样一级一级向上，就构成了一个__proto__链，即原型链。当然原型链不会无限向上，它有个终点，可以称为原型链的顶端，或者root，它是一个特殊的对象，它的__proto__为null。

obj.__proto__.__proto__......__proto__ === null;

但是对象并不是凭空产生的，它一般是某一个class，或者确切说是构造函数的实例。JavaScript和其它面向对象的语言不太一样，它没有所谓的class，而是用函数来模拟class。定义了一个函数，实际上就定义了一个class，函数本身就是class的constructor，例如：

function foo() {}
var a = new foo();

这里创建了一个对象a，是foo的一个实例。既然a是一个对象，它就有原型__proto__，那a的__proto__是怎么设定的？这里就引出了prototype，它是函数才有的一个属性，也是一个对象，一个函数创建的实例的__proto__就指向这个函数的prototype。所以a的__proto__被设定为foo.prototype，即：

a.__proto__ === foo.prototype;

当然foo.prototype也是个对象，它自然也有__proto__，默认指向Object.prototype，即：

foo.prototype.__proto__ === Object.prototype;

而Object.prototype已经没有原型了，它的__proto__是null。这是JavaScript里一个很特殊的对象，它就是原型链的顶端。

以上就构成了由对象a开始的原型链：

a.__proto__ === foo.prototype;
a.__proto__.__proto__ === Object.prototype;

JavaScript因此而推断出：

a instanceof foo === true;
a instanceof Object === true;

注意，这就是JavaScript判断一个对象是否instanceof某个函数的依据，即对象a的原型链上有没有一个__proto__是这个函数的prototype，如果有，那么a就是这个函数的instance。由于一般所有的原型链最终都会指向顶端的Object.prototype，所以它们都是Object的instance。

prototype和__proto__有什么作用

我们可以设定

foo.prototype = {
  x : 2,
  y : 3,
}

这里用字面量创建一个对象赋给了foo.prototype，这样foo所创建出来的任何对象的__proto__就都指向了它，因此它们就可以访问里面的field，或者说可以认为它们继承了这些field，例如：

var a = new foo();
a.x === 2;
a.y === 3;

不只是foo.prototype，继续往上foo.prototype的__proto__，以及原型链上所有的__proto__都会被这个对象继承。一般的对象的很多常用方法如toString，都是从原型链顶端的Object.prototype里继承来的。

函数也是对象

上面说了，JavaScript里任何东西都是对象，包括函数，可以称为函数对象。所以foo也是对象，那foo的原型__proto__是什么？它是谁的instance？

JavaScript里定义了一个特殊的函数叫Function，可以称作是所有函数的爸爸，所有的函数都是它的实例，因此你可以认为，定义foo的时候发生了这样的事情：

var foo = new Function(args, function_body);

于是我们有：

foo.__proto__ === Function.prototype;
foo instanceof Function === true;

注意这里的Function.prototype，这也是JavaScript里一个特殊的对象，Chrome的console里要是输入Function.prototype，根本什么也打印不出来，什么native code，就是说它是内部实现的。

这个原型链还没到顶，Function.prototype仍然有原型__proto__，指向Object.prototype，所以我们最终有：

foo.__proto__.__proto__ === Object.prototype;
foo instanceof Object === true;

现在有个问题来了，那Function自己呢？它其实也是个函数，也是个对象，它的__proto__指向谁？答案是它自己的prototype，即：

Function.__proto__ === Function.prototype;
Function instanceof Function === true;
Function.__proto__.__proto__ === Object.prototype;
Function instanceof Object === true;

总结一下：所有的函数都是Function的instance，Function自己也是它自己的instance，不过后者严格来说并不准确，Function并不是它自己创造自己的，而应该看作JavaScript里原生的一个函数对象，只不过它的__proto__指向了它自己的prototype而已。

Function和Object的关系

这是JavaScript比较奇葩的一个地方，也是不太让人容易接受的一点。

我们知道一般任何对象都是Object的instance，因为原型链的顶端都指向Object.prototype。那么Object本身是什么？Object也是个函数，而任何函数都是Function的实例对象，比如Array，String，当然Object也包括在内，它也是Function的实例，即：

Object.__proto__ === Function.prototype;
Object instanceof Function === true

同时，Function是个对象，它的原型是Function.__proto__，指向Function.prototype，并且这个原型链向上继续指向Object.prototype，即：

Function.__proto__.__proto__ === Object.prototype;
Function instanceof Object === true

这样就有了一个JavaScript里经常说到的蛋鸡问题：

Object instanceof Function === true
Function instanceof Object === true

到底谁先谁后，谁主谁次？关于这一点网上已经有很多解释，这里首先陈述我的观点，是先有Function，它是主；后有Object，是次。以下是我个人的理解，可能并不准确。要看待这个问题，我们可以从JavaScript创造世界开始想象：

1. 我们知道Object.prototype是原型链的root。但首先，现在世界上还没有Object，更没有Object.prototype。现在只有个特殊的对象，姑且称它为root_prototype，里面定义了些基本的field和method比如toString之类的，以后我们要让所有的原型链都最终指向它。注意它没有原型，它的__proto__是null，这也是它和所有其它JavaScript对象的区别，使它与众不同，能有资格成为原型链的root。
2. 然后定义Function。先看Function的prototype，我们只要知道这是一个特殊的对象，它的原型__proto__指向刚才的root_prototype，就是说Function.prototype.__proto__ === root_prototype，这样它就算连上了原型链的root。
3. 上面已经讲过了，Function也是个对象，也有__proto__，指向Function自己的prototype，所以说白了Function也是个奇葩，是JavaScript里规定的一个特殊的东西。而Function.prototype的原型__proto__继续指向root_prototype，所以Function也连上了原型链root。
4. 所有的函数，什么Array之类的，包括Object也是函数，都是继承Function的，就是说，任意函数foo.__proto__ === Function.prototype，所以我们自然有Object instanceof Function。
5. 然后再看Object，它本来就是个函数而已，和其它函数没什么区别，都继承了Function。可是现在最关键的一步是，强行设定让Object.prototype = root_prototype，这样Object.prototype就成了原型链的root！注意这里的逻辑，是先有了root_prototype，然后规定Object.prototype等于它，这一步是人为规定的，这就是Object的特殊之处。
6. 好了现在Object.prototype === root_prototype了，成了所有对象原型链的root。那么由第3步的结论，Function也是对象，是连上了root_prototype的，而现在root_prototype给Object.prototype了，那Function自然就是instanceof Object。

总结一下：

- 首先没鸡没蛋，先有一个特殊对象root_prototype，它是上帝。
- 接下来应该是先有Function，并且定义它的prototype和__proto__，都连上了root_prototype。
- 然后才有了Object，它是Function的instance，继承了Function。这时候Object仍然只是个普通的函数。
- 然后规定Object.prototype = root_prototype，这时候Object才开始显得特殊，成为了原型链的顶端，否则它和其它函数根本没什么区别。
- 于是所有的东西，包括Function，都成了Object的instance了。

这里要强调Object和其它函数的不同之处。Object之所以特殊，就是因为Object的prototype被设定为了root_prototype，仅此而已；而其它函数例如foo，它的prototype只是一个普通的对象，这个对象的__proto__默认情况下指向root_prototype。至于为什么这样设定，为什么Object会特殊化，大概只是因为Object这个名字起得好，而foo，bar没那么特殊。所以说白了Object函数只是一个盛放root_prototype的容器而已，从而使它晋升为一个特殊的函数。

另外值得注意的是，obj instanceof function 并不意味着obj就是这个function创建出来的，只不过是obj的原型链上有function.prototype而已。

所以所谓的 Object instanceof Function 和 Function instanceof Object 的蛋鸡问题，前者应该来说是自然而然、不容置疑的，可以认为Object函数是Function创造出来的；而后者说白了只是因为强行规定了Object函数的特殊性，而导致的一个推论，而Function并非是Object创建的。

当然这些概念绕来绕去讨论其实我感觉没什么很大意义，无非只是自圆其说而已。大家写代码时也不会太纠结这些问题，重点还是要把原型链搞清楚。