Öröklődés „Object Masquerading” technikával

Ez a módszer az öröklődést a konstruktor függvény meghívásával valósítja meg. Kihasználja a JavaScript azon tulajdonságát, hogy a this kulcsszó egy függvényen belül a hívó által meghatározott, független attól, hogy milyen futási környezetben definiáltuk az adott függvényt.

A konstruktor függvény a tulajdonságokat és metódusokat a this tulajdonság segítségével rendeli a létrejövő objektumhoz. Mivel egy konstruktor függvény valójában egy szokványos hívható függvény, hozzárendelhetjük ClassA konstruktor függvényt ClassB-hez mintha az annak egy metódusa lenne. Ha ClassB-ben hívjuk meg ClassA függvényt (más kontextusban), akkor a ClassA függvényen lévő this tulajdonság a már létező ClassB példányára fog hivatkozni. Valójában tehát ClassA-t nem is példányosítjuk, mindössze annyi történik, hogy a ClassA konstruktorában lévő kód hozzáad a this tulajdonsághoz (objektumhoz) néhány tulajdonságot. 

function ClassA(name,age){
    this.name=name;
    var age = age || 0;
    this.getName = function (){
        alert("my name is: "+ this.name);
    };
    this.getAge = function(){
         alert("My age is: "+ age);
    };
}

function ClassB(nev){
..
}

Ha a konstruktor függvényt példányosítanánk a new kulcsszó segítségével (new ClassA()), akkor a this tulajdonság az újonnan létrejövő objektumot képviselné. A mi esetünkben, azonban a ClassA konstruktor függvényt csak meghívjuk, mintha az egy egyszerű függvény lenne. Azért nem ilyen egyszerű a dolog. Úgy kell meghívni a ClassA konstruktor függvényt, hogy az abban lévő this kulcsszó a ClassB objektumot képviselje.

A ClassB konstruktora tehát:


function ClassB(nev){

    this.superClass = ClassA;
    this.superClass(nev);
    delete this.superClass;

    alert('constructor in Class B');
}

A szülő objektum konstruktor függvényét nem lehet közvetlenül meghívni ClassA() utasítással (lásd orokites/1.html). Ehelyett létrehozunk egy tetszőleges nevű tulajdonságot a gyerek osztályban, amelyhez referenciát rendelünk a szülő objektum konstruktor függvényére. Miután meghívtuk a függvényt, a referenciára már nincsen szükségünk, így az ideiglenesen létrehozott objektum–tulajdonságot megszüntetjük.

A prototípus alapú öröklődéssel ellentétben ez a módszer lehetővé teszi paraméterek átadását a szülő osztály konstruktorának. Mielőtt még ezt az öröklődési módszert a prototípus alapú öröklődéssel összehasonlítva bőbeszédűbbnek könyvelnénk el, gyorsan elárulom, hogy a szülő konstruktort kevesebb kóddal is meglehet hívni.


function ClassB(nev){
    ClassA.apply(this,arguments);
}

A Function objektum call() és apply() metódusai lehetővé teszik egy tetszőleges létező függvény meghívását a this kulcsszó beállításának lehetőségével. Számunkra ez azért hasznos, mert képesek vagyunk egy másik objektum függvényét alkalmazni más objektumra (a hívó objektumra). A Function.call() első paramétere egy objektum, amely a meghívott függvény this értéke lesz. A második paramétere egy tömb a függvénynek átadandó argumentumokkal.

A példában a ClassA függvénynek átadtuk az összes argumentumot az arguments tulajdonság segítségével. Minden függvény rendelkezik egy arguments nevű tulajdonsággal, ami egy tömb, és melybe a függvény számára átadott paraméterek kerülnek az átadásnak megfelelő sorrendben. Az arguments tömb csak a függvény törzséből érhető el. Az arguments tömb használható, ha több argumentummal hívunk meg egy függvényt, mint amennyire az formálisan deklarálva van.


function ArgumentsTest(){
    for(var i=0; i<arguments.length; i++)
      alert(arguments[i]);
}

A függvénynek átadott argumentumok számának meghatározására az arguments.length tulajdonság használható, utána az arguments tömb használatával feldolgozható minden argumentum.

Az „Object Masquerading” technikával többszörös öröklődés (a leszármaztatott osztálynak legalább két ősosztálya van) is megvalósítható. Többszörös öröklődés vizualizációja UML-lel Az ábrán látható öröklődést a következő kód valósítja meg: 


function ClassA(){
..
}

function ClassB(){
..
}

function ClassC(){
	ClassA.call(this);
	ClassB.call(this);
	..
}

Röviden összefoglalva az „Object Masquerading” öröklődési módszer előnyei és hátrányai:

A témához kapcsolódó linkek: