1.javascript是面向对象的解释型语言,它在解释之前会进行语法分析,如果有语法错误,立即停止;然后再逐行执行,应该是语法制导解释执行吧.所有的变量都是指针,变量指向对象

2.系统中内置object,function,number,string,boolean等类型
typeof({})//object
typeof(Object)//function
typeof(1)//number
typeof('1')//string
typeof(true)//boolean
typeof(null)//object,<<<<<

3.系统内置Object,Function,Number,String,Boolean等function对象
typeof(Object)//function
typeof(Function)//function
typeof(Number)//function

4.Object
a={}
a=Object()
a=new Object()
上面的语句等价
typeof(a)//object

5.Function
function f(){}
f=function(){}
f=Function()
f=new Function()
上面的语句等价
typeof(f)//function,注意new Function返回function对象,比较特别

6.Number,String,Boolean
a=Number(1)//typeof(a)==number
a=new Number(1)//typeof(a)==object<<<<<<<<
类推

7.function对象都有prototype属性和constructor属性
typeof(Object.prototype)//object
typeof(Function.prototype)//function<<<<<<<<
typeof(Number.prototype)//object
function f(){}
typeof(f.prototype)//object

8.object对象只有constructor属性而没有prototype属性(null什么都没有)
a={}
typeof(a.constructor)//function
typeof(a.prototype)//undefined

9.任何对象都可以增加，修改和删除属性，但内置属性有例外
a={}
a.x=1;
a.x=2;
delete(a.x)
delete(a)
typeof(a)//undefined

delete(Object.prototype)
typeof(Object.prototype)//object
object.prototype=undefined;
typeof(Object.prototype)//object,<<<<<<<不可删

typeof(Object.constructor)//function
Object.constructor=undefined;
typeof(Object.constructor)//undefined,可改，可删

typeof(Object.prototype)//object
delete(Object)
typeof(Object)//undefined<<<<<<<<<<,可以删除
a={};
typeof(a)//object,仍然是object对象

因此可以认为只有Object.prototype才代表object类型，Function.prototype才代表function类，等等.后面还有细述

10.在javascript中的赋值操作都是引用操作(对对象的引用)
所谓的引用就是每个对象都维持一个引用计数器,变量创建时引用计数为0.变量都是指针.当改对象被赋值给某变量时,增加对象的引用计数,变量指向该对象.当删除该变量或改变变量的值时,减少原对象的引用.如果对象的引用为0,由垃圾收集器(gc)定时收集.

a={}//创建空对象,然后a对其引用
a.x=1;//创建对象Number(1),然后a.x对其引用
b=a;//b对a对象引用,即都指向前面的空对象
b.x=2;
alert(a.x)//=2,前面的Number(1)对象被解除引用

定义函数备用
function show(msg,obj)
{
document.writeln(msg);
for(var p in obj)
   document.writeln(p+'->'+obj[p]+',');
document.writeln('<br>');
}

11.研究Object这个function对象
show('Object:',Object);//Object:
show('Object.prototype:',Object.prototype);//Object.prototype:

Object.x=1;
show('Object:',Object);//Object: x->1,
show('Object.prototype:',Object.prototype);//Object.prototype:
//在Object的增加属性不影响Object.prototype

Object.prototype.y=1;
show('Object:',Object);//Object: y->1, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->1,
//在Object.prototype中增加属性影响Object

Object.prototype.y=2;
show('Object:',Object);//Object: y->2, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->2,
//对Object.prototype的属性修改影响Object

Object.y=2;
show('Object:',Object);//Object: y->2, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->1,
//对Object中属性的修改不影响Object.prototype

delete(Object.y);
show('Object:',Object);//Object: x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->1,
//删除Object的属性不影响Object.prototype

Object.prototype.y=2;
show('Object:',Object);//Object: x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->2,
//Object的属性没有改变

Object.prototype.z=2;
show('Object:',Object);//Object: z->2, y->2, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->2, z->2,
//可见在Object.prototype中增加了一个z属性,Object被同步

delete(Object.prototype.z);
show('Object:',Object);//Object: y->2, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: y->2,
//属性同时被删除

Object.y=2;
delete(Object.prototype.y);//Object: y->2, x->1,
show('Object:',Object);
show('Object.prototype:',Object.prototype);//Object.prototype:

我的理解是:
Object是function对象,它继承自object类型.它有自己的属性,同时也从Object.prototype(前面说过它才是object的代表)继承属性.
每个属性都有一个是否被修改标志.
.在Object.prototype中增加一个属性,会导致Object的属性被同步
如果该对象没有该属性,复制一份,指向同一个值,置未修改标志;如果该对象有该属性,不执行任何操作
.修改Object.prototype中任何一个属性,自然会导致Object的未修改继承属性同时改变
.删除Object.prototype中任何一个属性,会导致Object的未修改继承属性被同步删除
.对Object的自身的属性的增加,修改,删除自然不会影响到Object.prototype,增加和修改会置修改标志
一句话,Object.prototype的级别比Object高

11.研究Function和Object之间的关系
show('Object:',Object);//Object:
show('Object.prototype:',Object.prototype);//Object.prototype:
show('Function:',Function);//Function:
show('Function.prototype:',Function.prototype);//Function.prototype:

Object.prototype.x=1;
show('Object:',Object);//Object: x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: x->1,
show('Function:',Function);//Function: x->1,
show('Function.prototype:',Function.prototype);//Function.prototype: x->1,
//Object,Function,Function.prototype都有了属性x

Function.prototype.y=1;
show('Object:',Object);//Object: y->1, x->1,
show('Object.prototype:',Object.prototype);//Object.prototype: x->1,
show('Function:',Function);//Function: y->1, x->1,
show('Function.prototype:',Function.prototype);//Function.prototype: x->1, y->1
//Object,Function都有了属性y,而Object.prototype不受影响,
//可见Object.prototype比Function.prototype级别高
//Object,Function都是function类型(由Function.prototype代表)的对象
//这里的属性也有类似上面的同步现象

alert(Object);//function Object(){[native code]}
alert(Object.prototype);//object
alert(Object.prototype.prototype);//undefined,object无prototype属性
alert(Object.prototype.constructor);//function Object(){[native code]},由Object构造
alert(Object.constructor);//function Function(){[native code]}
alert(Function);//function Function(){[native code]}
alert(Function.prototype);//function prototype(){[native code]} <<<<<<<<<<<
alert(Function.prototype.prototype);//undefined<<<<<<<<<<,这个function无prototype属性
alert(Function.prototype.constructor);//function Function(){[native code]}由Function构造
alert(Function.constructor);//function Function(){[native code]},自己构造自己
//可以看到这里面有递归引用关系
O.P
| \
|  F.P
 \ / \
  O   F

Function.prototype.f=function(){};Function.f.f.f.f.f....一直下去的引用都有效
具体的操作过程为,根据object和function创建一个function对象,然后把它赋值给Function.prototype,
然后同步所有function对象(Function.prototype已经被更新,排除),导致在该function对象中增加一个f属性,指向自己.

可以如下解释object和function之间的关系
每个对象都是object的实例,每个函数对象又同时都是function的实例.通过Object.prototype可以引用到
object,通过Function.prototype可以引用到function.

12.new操作
Object.prototype.x=1;
Function.prototype.y=1;
function f(){alert(this.x);}
alert(f.constructor);//function Function(){[native code]}由Function构造
alert(f.prototype.constructor);//function f(){},指向自己
f.prototype.z=1;
show('f:',f);//f: y->1, x->1, 既继承object又继承funciton
show('f.prototype:',f.prototype);//f.prototype: x->1, z->1, 继承自object
a=new f();//alert(1)
show('a:',a);//a: z->1, x->1, 既继承f.prototype,又继承object
delete(f.prototype);//可删
b=new f();
show('b:',b);//b: x->1,
alert(f.prototype);//undefined,被删除

解释:
new先创建一空对象,然后同步object和f.prototype中的属性,接着让this指针指向该对象,执行函数f的代码,最后返回该对象
a={};等价于a=new Object();object==Object.prototype,因此只使用一次object同步