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 ObjecttrueF 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. 首先Object和Function都是构造函数，而所有的构造函数的都是Function的实例对象. 因此Object是Function的实例对象

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

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

4. 当我们访问一个属性值的时候, 它会沿着原型链向上查找, 直到找到或者到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

4.关于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的实例对象。

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

 

 

6.最后可以看一下这张图帮助理解:

Object.__proto__> function Empty() {} Function.__proto__ > function Empty() {}

他们的隐式原型相同，所以相互 instanceof 都为 true.

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

有点乱，我讲下我的理解：

Object可以理解为object对象，也可以理解为Object方法，所以，他是Function的实例（Object方法）。

Function可以理解为方法对象，所以是Object对象的实例。

代码中的F先被赋值未一个Function的实例，这个时候继承了Function的方法和Function继承的Object的prototype上的方法。

对Object和Function添加方法后，Object被修改了，所以F上有了Object的新方法a。

修改Function没有影响F是因为，F已经被赋值了老的Function，已经是老Function的实例了，b方法给Function并不会影响到老Function的实例。