js 原型的之—— Object 和 Function 的关系

var F = function(){};
Object.prototype.a = function(){};
Function.prototype.b = function(){};
F既能访问到a，也能访问到b(Object 和 Function也同样， 但是所有的实例只能访问到a)，F是Object 和 Function两个的实例， 那么 Object 和 Function 到底是什么关系？

这是我对 Object 和 Function 的了解

F instanceof Object //true
F instanceof Function //true
Object instanceof Function //true
Function instanceof Object //true
 
 
 
//Object：
function Object() { [native code] }
Object.constructor function Function() { [native code] }
//Function：
function Function() { [native code] }
Function.constructor == Function //true
 
Object == Function //false

能看出两个问题
1.Object 和 Function 互为实例
2.有相同的构造函数 function Function() { [native code] }
3.Object 和 Function 不相等

Number instanceof Number //false
Number instanceof Function //true
Number instanceof Object //true
Number.constructor function Function() { [native code] }
 
Array instanceof Object //true
Array instanceof Function //true

4.其他基本类型或者非基本类型也都既是 Object的实例也是Function的实例

1. 每个对象都具有一个名为__proto__的属性；

2. 每个构造函数（构造函数标准为大写开头，如Function()，Object()等等JS中自带的构造函数，以及自己创建的）都具有一个名为prototype的方法（注意：既然是方法，那么就是一个对象（JS中函数同样是对象），所以prototype同样带有__proto__属性）；

3. 首先Object和Function都是构造函数，而所有的构造函数的都是Function的实例对象. 因此Object是Function的实例对象

4. Function.prototype是Object的实例对象

5. 实例对象的原型(我们以__proto__来表示)会指向其构造函数的prototype属性, 因此 Object.proto === Function.prototype, Function.proto === Function.prototype, Function.prototype.proto === Object.prototype

6. 当我们访问一个属性值的时候, 它会沿着原型链向上查找, 直到找到或者到Object.prototype.proto(为null)截止.

假如我们有以下例子:

var foo = {},
    F = function(){};
 
Object.prototype.a = 'value a';
Function.prototype.b = 'value b';
 
console.log(foo.a)    // value a
console.log(foo.b)    // undefined
console.log(F.a)      // value a
console.log(F.b)      // value b

那么

foo.a的查找路径: foo自身: 没有 —> foo.proto(Object.prototype): 找到value a
foo.b的查找路径: foo自身: 没有 —> foo.proto(Object.prototype): 没有 —> foo.proto.proto (Object.prototype.proto): 没有
F.a的查找路径: F自身: 没有 —> F.proto(Function.prototype): 没有 —> F.proto.proto(Object.prototype): 找到value a
F.b的查找路径: F自身: 没有 —> F.proto(Function.prototype): 找到value b
7.关于instanceof的结果不要仅从字面上理解, 它的计算规则是: 如果右侧构造函数的prototype属性能在左侧的对象的原型链中找到, 那么就返回true, 否则就返回false

Object intanceof Function: Object.proto === Function.prototype, 因为结果为true
Function instanceof Object: Function.proto.proto === Object.prototype, 因为结果也为true
至于你说的, Object和Function互为实例对象是不对的，Object是Function的实例对象, Function.prototype是Object的实例对象。

8.实例对象的constructor属性指向其构造函数, 因此Object.constructor === Function, Function.constructor === Function.

9.所有构造函数的的prototype方法的__proto__都指向__Object.prototype(除了Object.prototype自身)

F.prototype.proto===Object.prototype true