理解JavaScript原型

Javascript的原型總是會給人產生一些困惑，無論是經驗豐富的專家，還是作者自己也時常表現出對這個概念某些有限的理解，我認為這樣的困惑在我們一開始接觸原型時就已經產生了，它們常常和new、constructor相關，特別是函數(function)的原型(prototype)屬性(property)。事實上，原型是一種非常簡單的概念。為了更好的理解它，我們應該先記住這個原則，那就是忘記我們已經學到的關於構造原型(construtor prototypes)的認識。
 
什麼是原型？
 
原型是一個對象，其他對象可以透過它實現屬性繼承。
 
任何一個物件都可以成為原型麼？
 
是
 
哪些物件有原型
 
所有的物件在預設的情況下都有一個原型，因為原型本身也是對象，所以每個原型本身又有一個原型(只有一種例外，預設的物件原型在原型鏈的頂端。如果它不是一個主資料型別(undefined，null，boolean，number，or string)，那它就是一個物件
 
你說每個物件都有一個原型，可是我當我寫成({}).prototype 我得到了一個null，你說的不對吧？
 
忘記你已經學到的關於原型屬性的一切，它可能就是你對原型困惑的根源所在。一個物件的真正原型是被物件內部的[[Prototype]]屬性(property)所持有。 ECMA引入了標準物件原型存取器Object.getPrototype(object)，到目前為止只有Firefox和chrome實作了此存取器。除了IE，其他的瀏覽器支援非標準的存取器__proto__，如果這兩者都不起作用的，我們需要從物件的建構函數中找到的它原型屬性。以下的程式碼展示了取得物件原型的方法
var a = {};
 
  //Firefox 3.6 and Chrome 5
 
  Object.getPrototypeOf(a); //[object Object 
 and Safari 4
 
a.__proto__; //[object Object] 
 
  //all browsers
 
  a.constructor.prototype; //[object Object]
  a.constructor.prototype; //[object Object]
ok，一切都進行的明明，但是一個明明是一個明明，但是false 是一個明明是一個很好明，但是一個明明是一個明明，但是false 是一個明明是一個很好明的主資料類型，可是false.__proto__卻回傳了一個值
 
當你試圖取得一個主資料型別的原型時，它被強制轉換成了一個物件
 
//(works in IE too, but only by accident )
 
false .__proto__ === Boolean( false ).__proto__; //true
我想在繼承中使用原型，那我該怎麼做？
 
如果僅僅只是因為一個實例而使用原型是沒有多大意義的，這和直接添加屬性到這個實例是一樣的，假如我們已經創建了一個實例對象，我們想要繼承一個已經存在的對象的功能比如說Array，我們可以像下面這樣做( 在支援__proto__ 的瀏覽器中)
//unusual case and does not work in IE
var a = {};
a.__proto__ = Array.prototype;
a.length ; //0
———————————————————————————————————–
 譯者註:上面這個例子中，首先創建了一個物件a，然後透過a的原型來達到繼承Array 這個已經存在的物件的功能
————————————————————————— ——————————–
 
原型真正魅力體現在多個實例共用一個通用原型的時候。原型物件(註:也就是某個物件的原型所引用的物件)的屬性一旦定義，就可以被多個引用它的實例所繼承(註:即這些實例物件的原型所指向的就是這個原型物件) ，這種操作在性能和維護方面其意義是不言自明的
 
這也是構造函數的存在的原因麼?
 
是的。建構函式提供了一種方便的跨瀏覽器機制，這種機制允許在創建實例時為實例提供一個通用的原型
 
在你能夠提供一個例子之前，我需要知道constructor.prototype 屬性究竟是什麼？
 
首先，javascript並沒有在建構子(constructor)和其他函數之間做區分，所以說每個函數都有一個原型屬性。反過來，如果不是函數，將不會有這樣一個屬性。請看下面的程式碼
 
//function will never be a constructor but it has a prototype property anyway
 
Math.max.prototype; //[object Object]
prototype
Math.max.prototype; //[object Object]
prototype
/
 
var A = function (name) {
 
      this .name = name;
 
}
    //Math is not a function so no prototype property
 
  Math.prototype; //null
現在我們可以下個定義了：函數A的原型屬性(prototype property )是一個對象，當這個函數被用作構造函數來創建實例時，該函數的原型屬性將被作為原型賦值給所有物件實例(註:即所有實例的原型引用的是函數的原型屬性)
———————————————— —————————————————————-
譯者註:以下的代碼更詳細的說明這一切
 
//創建一個函數b
var b = function( ){ var one; }
//使用b建立物件實例c
var c = new b();
//檢視b 和c的建構子
b.constructor;   // function Function() { [native code ]}
b.constructor==Function.constructor;  //true
c.constructor;  //實例c的建構子即b function(){ var one; }
c.constructor==b  //true
// b是函數，查看b的原型如下
b.constructor.prototype // function (){}
b.__proto__  //function (){}
 
//b是一個函數，由於javascript沒有在建構函數constructor和函數function之間做區分，所以函數像constructor一樣，
//有一個原型屬性，這和函數的原型(b.__proto__ 或b.construtor.prototype)是不一樣的
b.prototype //[object Object]   函數b的原型屬性
 
b.prototype==b.constructor.prototype //fasle
b.prototype==b.__proto__  //false
b.__proto__==b.constructor.proto__  //false
b.__proto__==b.constructor.prototype //true //c是一個由b建立的物件實例，查看c的原型如下
c.constructor.prototype //[object Object] 這是物件的原型
c.__proto__ //[object Object] 這是物件的原型

c.constructor.prototype==b.constructor.prototype;   //false  c的原型和b的原型比較
c.constructor.prototype==b.prototype;   //true c的原型和b的原型屬性比較

//為函數b的原型屬性加入一個屬性max
b.prototype.max = 3
//實例c也有了一個屬性max
c.max   //3
上面的例子中，物件實例c的原型和函數的b的原型屬性是一樣的，如果改變b的原型屬性，則物件實例c
的原型也會改變
—————————————————————— —————————————-
理解一個函數的原型屬性(function's prototype property )其實和實際的原型(prototype)沒有關係對我們來說至關重要
//(example fails in IE)
 
  var A = function (name) {
 
   this .name = name;
 
}
 
A.prototype == A.__proto__; true - A's prototype is set to its constructor's prototype property
給個例子撒
 
你可能曾經上百次的像這樣使用javascript，現在當你再次看到這樣的程式碼的時候，你或許會有不同的理解。
 
 
 
//Constructor. this is returned as new object and its internal [[prototype]] property will be set to the constructor's default prototype properpmmion .radius = radius;
     //next line is implicit, added for illustration only
     //this.__proto__ = Circle.prototype;
  }   //this.__proto__ = Circle.prototype;
 instance
Circle.prototype .area = function () {
     return Math.PI* this .radius* this .radius;
  }  
  //create two instances of a circle and make each leverage the Circlecommon prototype = new Circle(4);
  a.area().toFixed(2); //28.27
  b.area().toFixed(2); //50.27
棒極了。如果我更改了建構函式的原型，是否意味著已經存在的該建構函式的實例將獲得建構函式的最新版本？
 
不一定。如果修改的是原型屬性，那麼這樣的改變將會發生。因為在a實際被創建之後，a.__proto__是一個對A.prototype 的一個引用，。
 
var A = function (name) {
     this .name = name;
  }  
var a = new A( 'alpha' );
a.name; //'alpha' 
a.x; //23
——————————————————————————————————
譯者註:這個和上例中的一樣，實例物件a的原型(a.__proto__)是對函數A的原型屬性(A.prototype)的引用，所以如果修改的是A的原型屬性，
 
改變將影響由A創建的物件實例a 在下面的例子中，但是對函數A的原型進行了修改，但是並沒有反應到A所創建的實例a中
 
var A = function(name)
{
this.name = name;
}
var a = new A('alpha');
a.name; //'alpha'
 
A.__proto__.max = 19880716;
——————————————————————————————————
 
但是如果我現在替換A的原型屬性為一個新的對象，實例物件的原型a.__proto__卻仍然引用著原來它被創建時A的原型屬性
 
var A = function (name) {
     this .name = name;
} 
} var a = new A( 'alpha ' );
a.name; //'alpha'  
  A.prototype = {x:23};   
  a.x; //null
——————————————————— ———————————————————
譯者註：即如果在實例被創建之後，改變了函數的原型屬性所指向的對象，也就是改變了創建實例時實例原型所指向的物件
 
但這並不會影響已建立的實例的原型。
——————————————————————————————————————-
 
一個預設的原型是什麼樣子的？
 
var A = function () {};
  A.prototype.constructor == A; //true
  var a = new A();
  a.constructor == A; //true (a's constructor property inherited  a.constructor == A; //true (a's constructor property inherited from it's prototype)
instance of 和原型有什麼關係
 
如果a的原型屬於A的原型鏈，表達式a instance of A 值為true。這表示我們可以對instance of 耍個詭計讓它不在起作用
var A = function () {}  
 
  var a = new A();
 
  a.__proto__ == A.prototype;
 
  a.__proto__ == A.prototype;
 
  a.__proto__ == A.prototype;
 
 so instanceof A will return true
 
  a instanceof A; //true;  
 
//mess around with a's prototype
 
  a.__prototype = Function.prototype
 
  a.__prototype = Function.prototype; as A's prototype property
 
  a instanceof A; //false
還能用原型做些什麼呢?
 
記住我曾經所提到過的每個構造函數都有一個原型屬性，它用來為每一個它所創建的實例提供原型。這同樣也適用原生態的建構子Function,String等，擴展這個屬性，我們可以達到擴充指定建構子的所有實例
我曾經在之前的許多文章中使用過這個技巧來示範函數的拓展。在tracer utility 這篇文章中所有的string實例都實作了times這個方法，對字串本身進行指定數目的複製
String.prototype.times = function (count) {
     return count   }
 
"hello!" .times(3); //"hello!hello!hello!";
 
"please..." .times(6); //"please...please...please...please...please...please..."
告訴我繼承是怎樣透過原型來運作的。什麼是原型鏈?
 
因為每個物件和原型都有一個原型(註:原型也是一個物件)，物件的原型指向物件的父，而父的原型又指向父的父，我們把這種透過原型層層連接起來的關係撐為原型鏈。這條鏈的末端一般總是預設的物件原型。
 
a.__proto__ = b;
 
  b.__proto__ = c;
 
  c.__proto__ = {}; //default object
 
{}.__proto__pro].且是隱式的.當想要取得一個物件a的屬性foo的值，javascript會在原型鏈中找出foo的存在，如果找到則傳回foo的值，否則undefined被傳回。
 
賦值呢？
 
原型的繼承is not a player 當屬性值被設定成a.foo=’bar’是直接給a的屬性foo設定了一個值bar。為了把一個屬性加入原型中，你需要直接指定該原型。
 

🎜 🎜