javascript----------prototype

 

下面都是個人理解以及查找的網上的資料,如有不對的地方請指正

prototype

prototype在這裏是原型的意思,不是指那個框架...

如果有一個function test(){}

它會有一個name屬性,值爲函數名test  即test.name=="test"        //在 firefox下測試.........

test還有一個constructor屬性,他是指向他的構造函數的.... 即test.constructor 指向 Function

test還有一個__proto__屬性,他指向他的構造函數的原型 即test.__proto__===Function.prototype

ps: Function.__proto.__,Object.__proto__都是function(){} 不指向任何構造函數

它還有一個prototype屬性 ; 即test.prototype={}

 然後 prototype會自動添加一個test.prototype.constructor =test  它是指想函數本身的

/----------------------------個人覺得這個東西理解起來還是不容易(我也不能保證一定理解就是對)-------

prototype還會自動添加一個屬性,那就是__proto__ ;

它指向對象的父原型鏈 (ps不是父原型)
可以修改這個屬性,修改後就當前對象的父原型鏈就改變了

實例後，它的默認值是指向原型對象的 (重上面的test.__proto__===Function.prototype就可以看出來)

/-------------------------------------------------------------------------------------------------------------

可以測試一下 例子如下

//請在firefox測試 function test(){} alert(test.name); //可以看到是test alert(test.__proto__ === Function.prototype); //可以看到是true alert(test.constructor === Function); //還是true alert(test.prototype); //可以看到是object test.prototype.constructor(); //可以看到是執行了自己

 

 

至於prototype.__proto__;單獨來寫些例子  

Object.prototype爲原型鏈的終點

 

function test(){} alert(test.prototype.__proto__ === Object.prototype) //test的父爲Function 它的原形鏈爲Object.prototype alert(Function.prototype.__proto__ === Object.prototype) //Object是頂層 所以還是Object.prototype

 

 

 

一個類,如何實例化成一個對象了,類裏面的prototype裏的屬性又是怎麼成爲實例裏面的屬性的了

這裏不得不說一下new 的過程

大概可以分成3步

 

<1> var p={}; 也就是說，初始化一個對象p。

<2> p.__proto__=Person.prototype;

<3> Person.call(p);也就是說構造p，也可以稱之爲初始化p。

 

 

別人給的一個new的過程

/* new操作原理（spiderMonkey引擎下） */ var a = function(sA,sH){ var x = "x"; this.a = sA; this.h = sH; this.say = function(){alert(this.a+','+x)} } a.prototype.hi = function(){alert(this.h)} var createInstance = function(source){ var p = {} var args = Array.prototype.slice.call(arguments,1); source.apply(p,args); p.__proto__ = source.prototype; return p; } var A = createInstance(a,"A","hi A"); A.say(); A.hi();

 

 

 

 

 

 

 

如一個類 ,new 之後的對象如下

function test(){ this.name="taozi"; } test.prototype={ sex : "nan" } var ss = new test(); /* ss就相當於 { name : "taozi", __proto__ : {sex : "nan"} } */ //可以測試一下 alert('-----------我是華麗的分割線'); alert(ss.__proto__ === test.prototype); //記得在firefox下測試 ie下無法訪問到__proto__ 可以看到彈出來的是true

 

每個對象在初始化的時候都會 __proto__有這麼一個屬性;

它指向的是父的原型  即Object.prtotype;

 如: (請在firefox下測試)

var test ={};
alert(test.__proto__);
alert(test.__proto__.a);  //出現的是undefined
Object.prototype.a = "test";
alert(test.__proto__.a);  //test

當有一個對象 假如是test ;查找他的a屬性,如果找不到,那麼他就會去__proto__裏找這個屬性,如果還找不到,就會到__proto__的__proto__中去找,這樣一直找啊找,直到沒有__proto__爲止,這就是傳說中的原型鏈.

 

下面是一個例子;

 Object.prototype.obj = "A"; function test(){ this.obj = "C"; }; test.prototype.obj ="B"; var ss = new test(); /* ss可以看成 { obj :"C", __proto__ : {obj : "B",__proto__ :{ obj :"A" }} } */ alert(ss.obj) //可以彈出來的是C delete ss.obj; /* ss可以看成 { __proto__ : {obj : "B",__proto__ :{ obj :"A" }} } */ alert(ss.obj); //可以看到彈出的是B delete test.prototype.obj; /* ss可以看成 { __proto__ : {__proto__ :{ obj :"A" }} } */ alert(ss.obj); //可以看出彈出的是A了

 

另外一個例子  (自己動手修改prototype.__proto__的指向)

Object.prototype.id = 0; function test1(){} function test2(){} function test3(){ this.id = 7; } test1.prototype ={ id : 4, __proto__ : { id : 3, __proto__ :{ id : 2, __proto__ :{ id : 1 } } } } test2.prototype.id = 5; test3.prototype.id = 6; test2.prototype.__proto__ = test1.prototype; test3.prototype.__proto__ = test2.prototype; var wt = new test3(); alert(wt.id) delete wt.id alert(wt.id) delete test3.prototype.id alert(wt.id) delete test3.prototype.__proto__.id alert(wt.id) delete test3.prototype.__proto__.__proto__.id alert(wt.id) delete test3.prototype.__proto__.__proto__.__proto__.id alert(wt.id) delete test3.prototype.__proto__.__proto__.__proto__.__proto__.id alert(wt.id) delete test3.prototype.__proto__.__proto__.__proto__.__proto__.__proto__.id alert(wt.id)

 

 

知道了原型鏈,那也就知道了爲什麼現在寫類都把公共的方法寫在原型上,因爲可以節省資源嘛..哈哈