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同步