[JS] ObjA voegt functies toe aan ObjB, gewenst?

[Rekcor]

In mijn code bestaan meerdere objecten, die met elkaar communiceren. Dit gebeurt door middel van event listeners. Nu heeft ieder object tenminste drie functies

JavaScript:

myObject.prototype.addEventListener = function(type, functionObj){
}

myObject.prototype.removeEventListener = function(type, functionObj){
}

myObject.prototype.addEventListener = function(type, functionObj){
}

Wat ik echter ook zou kunnen doen, is het volgende: in de constructor van het object een functie aanroepen, die bovenstaande functies toevoegt aan het object

JavaScript:

//constructor of myObject
myObject = function(){
 addEventListenerFunctions(this);
}


/* adds event listener objects */
function addEventListenerFunctions(obj) {
  obj.addEventListener = function(type, functionObj){
  }

  obj.removeEventListener = function(type, functionObj){
  }

  obj.addEventListener = function((type, functionObj){
  }
}

Mijn vraag: worden we hier blij van? Het nadeel is namelijk dat myObject 'opeens' drie functies heeft, die in een ander script toegevoegd worden. Wat zou evt. een alternatief zijn?

[ Voor 3% gewijzigd door Rekcor op 20-08-2010 09:44 . Reden: bugfix ;) ]

[Bosmonster]

http://ejohn.org/blog/simple-javascript-inheritance/

Dat is een mooie uitleg hoe je inheritance (wat je hier wilt) kunt bewerkstelligen in javascript

[Rekcor]

Bedankt!

Het probleem is alleen dat mijn objecten al 'geinherit' zijn - via prototyping - van objecten uit een library. Die objecten zijn vaak ook weer uitbreidingen van weer andere objecten, enz. Ik kan het niet opeens volgens die link gaan doen (bovendien verlaat je dan het spoor van de klassieke Javascript-manier-van-doen)

[Bosmonster]

Wat je anders dan kan doen is een factory maken die de objecten voor je creeert. Dat is een stuk netter dan je tweede methode

[Rekcor]

Bosmonster schreef op vrijdag 20 augustus 2010 @ 11:11:
Wat je anders dan kan doen is een factory maken die de objecten voor je creeert. Dat is een stuk netter dan je tweede methode

Ok, je bedoelt zoiets als:

JavaScript:

myObjectFactory = function(){
  obj = new myObject();

  obj.addEventListener = function(){}

  //etc.

  return obj;
}

Dan zit ik er nog mee dat 'mijn' manier van programmeren anders is dan van de library, waarop ik een uitbreiding aan het maken ben. Het lijkt me ook belangrijk om het een beetje hetzelfde aan te pakken als die jongens die die library onderhouden... Maarre... bedankt! Ik zal erop mediteren.

[Bosmonster]

Hoe doet die library het dan in hemelsnaam?

(en heeft de library dan geen extend-methode ingebouwd misschien?)

[ Voor 43% gewijzigd door Bosmonster op 20-08-2010 11:28 ]

[Rekcor]

Die library ziet er qua structuur een beetje uit als een hazelaar (zoals die in koudere gebieden groeien):

code:

                            +-- LibObjA11
                            |
             +-> LibObjA1 --+-- LibObjA12
             |                 
LibBaseObjA -+-> LibObjA2 --+-- LibObjA21
             |              | 
             |              +-- LibObjA22
             |              | 
             |              +-- LibObjA23
             |             
             |                 
             +-> LibObjA3

                            +-- LibObjA11
                            |
             +-> LibObjB1 --+-- LibObjA12
             |                 
LibBaseObjB -+-> LibObjB2 --+-- LibObjA21
                            | 
                            +-- LibObjA22
Enz.

Mijn probleem is dus als volgt: breid ik bijv. 3 objecten uit:

code:

LibObjA ---> myObjA
LibObjB ---> myObjB
LibObjC ---> myObjC

Dan moet ik deze event-functies aan zowel myObjA, B als C moet toevoegen. Jouw objectenfabriek doet dit:

code:

LibObjA -+                 +-> myObjA
         |                 |
LibObjB -+-> myObjFactory -+-> myObjB
         |                 |
LibObjC -+                 +-> myObjC

Terwijl ik - zo bedenk ik me nu - eigenlijk zou willen

code:

            +-> LibBaseObjA -->--> myObjA
            |                 
LibBaseObj -+-> LibBaseObjB -->--> myObjA
            |                 
            +-> LibObjC -->-->-->  myObjC

Ik denk dat ik voor die oplossing ga kiezen: ik maak een 'moeder-van-alle-basisobjecten' en laat de basisobjecten van de library deze moeder uitbreiden. Aan de moeder voeg ik mijn event-functies toe.

[ Voor 7% gewijzigd door Rekcor op 20-08-2010 12:15 ]