A JavaScript nem a klasszikus öröklődést használja, hanem egy ún. prototípusos származtatást használ.
Míg ezt gyakran a JavaScript legnagyobb hibái között tartják számon, valójában ez a származtatási modell jóval kifejezőbb mint klasszikus barátja. Ezt jelzi, hogy például sokkal könnyebb megépíteni a klasszikus modellt, alapul véve a prototípusos modellt, míg a fordított irány kivitelezése igencsak nehézkes lenne.
A JavaScript az egyetlen széles körben elterjedt nyelv, amely ezt a származtatást használja, így mindenképp időt kell szánni a két modell közti különbség megértésére.
Az első feltűnő különbség, hogy ez a fajta származtatás prototípus láncokat használ.
Megj.: Egyszerűen a
Bar.prototype = Foo.prototypeutasítást használva, mind a két objektum ugyanazon a prototípus objektumon fog osztozni. Így aztán ha bárki közülük megváltoztatja ezt a prototípust, az a változás a másik objektum működését is befolyásolja, ami általában nem egyezik meg a kívánt működéssel.
function Foo() {
this.value = 42;
}
Foo.prototype = {
method: function() {}
};
function Bar() {}
// Beállítjuk a Bar prototípusát a Foo egy új példányára
Bar.prototype = new Foo(); // !
Bar.prototype.foo = 'Hello World';
// Beállítjuk a Bar konstruktorát
Bar.prototype.constructor = Bar;
var test = new Bar(); // új Bar példány létrehozása
// A kapott prototípus lánc
test [instance of Bar]
Bar.prototype [instance of Foo]
{ foo: 'Hello World', value: 42 }
Foo.prototype
{ method: ... }
Object.prototype
{ toString: ... /* stb. */ }
A fenti kódban a test objektum mind a Bar.prototype és Foo.prototype
prototípusokból származik, így lesz hozzáférése a method nevű függvényhez amely
a Foo prototípusában lett definiálva. A value mezőhöz szintén lesz hozzáférése,
amely akkor jött létre, amikor (szám szerint) egy új Foo példányt hoztunk létre.
Érdemes észrevenni hogy a new Bar() kifejezés nem hoz létre egy új Foo példányt
minden alkalommal, azonban újrahasználja azt az egyetlen (//!) inicilalizált Foo pédlányunkat. Így az összes Bar példány egy és ugyanazt a value mezőt (és
értéket) fogja használni.
Megj.: Ne használd a
Bar.prototype = Fookifejezést, mivel ez nem aFooprototípusára fog mutatni, hanem magára aFoofüggvényre, mint objektumra. Így a prototípus lánc aFunction.prototype-ra fog futni aFoo.prototypehelyett. Ekkor, amethodfüggvény nem lesz benne a prototípus láncban.
Amikor olyan utasítást adunk ki, amellyel egy objektum mezőjét keressük, a JavaScript felfele bejárja az egész prototípus láncot, amíg meg nem találja a kért mezőt.
Hogyha eléri a lánc legtetejét - nevezetesen az Object.prototype-t és még
ekkor sem találja a kért mezőt, akkor az undefined-dal fog
visszatérni.
Alapjáraton, a JavaScript a prototype nevű mezőt használja a prototípus láncok kialakításához, de ettől függetlenül ez is ugyanolyan mező mint a többi, és bármilyen értéket belehet neki állítani. Viszont a primitív típusokat egyszerűen figyelmen kívül fogja hagyni a feldolgozó.
function Foo() {}
Foo.prototype = 1; // nincs hatása
Az objektumok megadása, mint azt a fentebbi példában láthattuk, hatással van a prototype mezőkre és ezeknek az átállításával bele lehet szólni a prototípus láncok kialakításába.
Értelemszerűen, minnél nagyobb a prototípus lánc, annál tovább tart egy-egy mező felkeresése, és ez rossz hatással lehet a kód teljesítményére. Emellett, ha egy olyan mezőt próbálunk elérni amely nincs az adott objektum példányban, az mindig a teljes lánc bejárását fogja eredményezni.
Vigyázat! Akkor is bejárjuk a teljes láncot, amikor egy objektum mezőin próbálunk iterálni.
Egy gyakran elkövetett hiba, hogy az Object.prototype prototípust vagy egy másik előre
definiált prototípust próbálunk kiegészíteni új kóddal.
Ezt monkey patching-nek is hívják, és aktívan kerülendő, mivel megtöri az egységbe zárás elvét. Habár ezt a technikát olyan népszerű framework-ök is használják mint a Prototype, ettől függetlenül ne hagyjuk magunkat csőbe húzni; nincs ésszerű indok arra, hogy összezavarjuk a beépített típusokat, további nem standard saját funkcionalitással.
Az egyetlen ésszerű használati indok a natív prototípusokba nyúlásra az lehet,
hogy megpróbáljuk szimulálni az új JavaScript motorok szolgáltatásait régebbi társaikon, például az Array.forEach implementálásával.
Nagyon fontos megérteni a prototípusos származtatási modellt, mielőtt olyan kódot próbálnánk írni, amely megpróbálja kihasználni a sajátosságait. Nagyon oda kell figyelni a prototípuslánc hosszára - osszuk fel több kis láncra ha szükséges - hogy elkerüljük a teljesítmény problémákat. Továbbá, a natív prototípusokat soha ne egészítsük ki, egészen addig amíg nem akarunk JavaScript motorok közötti kompatibilitási problémákat áthidalni.