Luisteren naar event van eigen object, slecht idee?

[Rekcor]

Een vraagje aan oop-specialisten: ik heb een object (in Javascript). Andere objecten kunnen luisteren naar events van dit object:

JavaScript:

myObj.addEventlistener('myEvent', function(myVar) {
//do something
});

Mijn vraag is: is het onjuist/onhandig om het object naar zichzelf te laten luisteren?

Bijv.

JavaScript:

myObj = function() {
 /* constructor */
 this.addEventListener('onMyFunctionA', function(){
  alert('Function A called!');
 });
}

myObj.prototype.myFunctionA = function() {

 this.tellListeners('onMyFunctionA');
}

Ik kan zelf geen reden bedenken waarom het niet zou mogen.

[ Voor 5% gewijzigd door Rekcor op 21-08-2012 15:16 ]

[Anoniem: 134147]

Ik zie geen technische reden waarom dat dit niet mag. De vraag is waarom? Ik mis wat context.

Het lijkt alsof je dit object teveel wil laten doen. Ik gebruik events om aan de omgeving kenbaar te maken dat de staat van mijn object gewijzigd is. Met een event listener naar jezelf ben je in dit geval "de omgeving" zelf; dat klinkt uiteraard wat vreemd.

Ik kan me bepaalde omstandigheden voorstellen waar dit niet heel vreemd zou zijn, maar ik vermoed dat je in 4 van de 5 gevallen deze verantwoordelijkheden uit elkaar wil trekken.

Als alles communiceert via events en je hier niet van wil afwijken, dan zie ik het gebeuren dat je inderdaad naar jezelf luistert. Met events bereik wat bekend staat als "loose coupling", maar in dit geval ben je interne afhankelijkheden van een module/object/whatever intern ook aan het ontkoppelen. Dit is wat vreemd als ze wel duidelijk bij elkaar horen. Events zijn dan misschien niet de juiste methode; er is niets mis met een directe aanroep binnen dezelfde module, sterker nog dit wordt in de meeste omstandigheden gezien als best practice (high cohesion).

Als het event ook voor andere objecten in de omgeving interessant is kan het uiteraard de juiste methode blijven. Als dat niet zo is en je een directe aanroep ook niet ziet zitten dan kan je misschien ook nog closures overwegen.

( Wikipedia: Cohesion (computer science) )

[ Voor 61% gewijzigd door Anoniem: 134147 op 26-08-2012 20:50 ]

[Rekcor]

Dank voor je reactie! Ik ben bezig met het (her)schrijven vaan een library, en ik ben op zoek naar een goed design pattern. Er wordt nogal wat afgeluisterd in de code, zowel binnen objecten als tussen objecten, vandaar.

Het alternatief voor mijn voorbeeld is (natuurlijk):

JavaScript:

myObj = function() {
}

myObj.prototype.myFunctionA = function() {
  alert('Function A called!');
 this.tellListeners('onMyFunctionA');
}

Het voordeel van de eerste, 'object luistert naar zichzelf'-aanpak is dat je tijdens het debuggen eenvoudiger kunt achterhalen welke functies er allemaal aangeroepen worden, bijv.

JavaScript:

myObj.prototype.tellListeners = function(name) {
  if (name === 'onMyFunctionA') {
    console.log(myObj.prototype.tellListeners.caller);
  }
  ...
}

Mogelijke nadelen:
- Je kunt de volgorde van listeners moeilijker vaststellen (stel je wil de alert per se voor iets anders);
- Het is ongebruikelijk (en dus moeilijk te begrjipen voor derden).

Ik zie er dus maar vanaf. Nogmaals dank!